private void initStatementString(
final String projection,
final String condition,
final String orderBy,
final String groupBy,
final LockMode lockMode)
throws MappingException {
final int joins = countEntityPersisters(associations);
suffixes = BasicLoader.generateSuffixes(joins + 1);
JoinFragment ojf = mergeOuterJoins(associations);
Select select =
new Select(getDialect())
.setLockMode(lockMode)
.setSelectClause(
projection == null
? persister.selectFragment(alias, suffixes[joins]) + selectString(associations)
: projection)
.setFromClause(
getDialect().appendLockHint(lockMode, persister.fromTableFragment(alias))
+ persister.fromJoinFragment(alias, true, true))
.setWhereClause(condition)
.setOuterJoins(
ojf.toFromFragmentString(), ojf.toWhereFragmentString() + getWhereFragment())
.setOrderByClause(orderBy(associations, orderBy))
.setGroupByClause(groupBy);
if (getFactory().getSettings().isCommentsEnabled()) {
select.setComment(getComment());
}
sql = select.toStatementString();
}
/**
* 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);
}
}
}
/**
* Process a particular association owned by the entity
*
* @param associationType The type representing the association to be processed.
* @param persister The owner of the association to be processed.
* @param propertyNumber The property number for the association (relative to the persister).
* @param alias The entity alias
* @param path The path to the association
* @param nullable is the association nullable (which I think is supposed to indicate inner/outer
* join semantics).
* @param currentDepth The current join depth
* @throws org.hibernate.MappingException ???
*/
private void walkEntityAssociationTree(
final AssociationType associationType,
final OuterJoinLoadable persister,
final int propertyNumber,
final String alias,
final PropertyPath path,
final boolean nullable,
final int currentDepth)
throws MappingException {
String[] aliasedLhsColumns =
JoinHelper.getAliasedLHSColumnNames(
associationType, alias, propertyNumber, persister, getFactory());
String[] lhsColumns =
JoinHelper.getLHSColumnNames(associationType, propertyNumber, persister, getFactory());
String lhsTable = JoinHelper.getLHSTableName(associationType, propertyNumber, persister);
PropertyPath subPath = path.append(persister.getSubclassPropertyName(propertyNumber));
JoinType joinType =
getJoinType(
persister,
subPath,
propertyNumber,
associationType,
persister.getFetchMode(propertyNumber),
persister.getCascadeStyle(propertyNumber),
lhsTable,
lhsColumns,
nullable,
currentDepth);
addAssociationToJoinTreeIfNecessary(
associationType, aliasedLhsColumns, alias, subPath, currentDepth, joinType);
}
public String selectFragment(
Joinable rhs,
String rhsAlias,
String lhsAlias,
String entitySuffix,
String collectionSuffix,
boolean includeCollectionColumns) {
StringBuffer buf = new StringBuffer();
if (includeCollectionColumns) {
// buf.append( selectFragment( lhsAlias, "" ) )//ignore suffix for collection columns!
buf.append(selectFragment(lhsAlias, collectionSuffix)).append(", ");
}
OuterJoinLoadable ojl = (OuterJoinLoadable) getElementPersister();
return buf.append(
ojl.selectFragment(lhsAlias, entitySuffix)) // use suffix for the entity columns
.toString();
}
public AbstractEntityJoinWalker(
OuterJoinLoadable persister,
SessionFactoryImplementor factory,
Map enabledFilters,
String alias) {
super(factory, enabledFilters);
this.persister = persister;
this.alias = (alias == null) ? generateRootAlias(persister.getEntityName()) : alias;
}
protected final void initAll(
final String whereString, final String orderByString, final LockMode lockMode)
throws MappingException {
walkEntityTree(persister, getAlias());
List allAssociations = new ArrayList();
allAssociations.addAll(associations);
allAssociations.add(
new OuterJoinableAssociation(
persister.getEntityType(),
null,
null,
alias,
JoinFragment.LEFT_OUTER_JOIN,
getFactory(),
CollectionHelper.EMPTY_MAP));
initPersisters(allAssociations, lockMode);
initStatementString(whereString, orderByString, lockMode);
}
/**
* 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);
}
}
}
}
protected String getWhereFragment() throws MappingException {
// here we do not bother with the discriminator.
return persister.whereJoinFragment(alias, true, true);
}
// $Id: CascadeEntityJoinWalker.java,v 1.1 2005/07/26 05:51:47 oneovthafew Exp $