FromElement addFromElement() throws SemanticException {
FromClause parentFromClause = fromClause.getParentFromClause();
if (parentFromClause != null) {
// Look up class name using the first identifier in the path.
String pathAlias = PathHelper.getAlias(path);
FromElement parentFromElement = parentFromClause.getFromElement(pathAlias);
if (parentFromElement != null) {
return createFromElementInSubselect(path, pathAlias, parentFromElement, classAlias);
}
}
EntityPersister entityPersister =
fromClause.getSessionFactoryHelper().requireClassPersister(path);
FromElement elem =
createAndAddFromElement(
path,
classAlias,
entityPersister,
(EntityType) ((Queryable) entityPersister).getType(),
null);
// Add to the query spaces.
fromClause.getWalker().addQuerySpaces(entityPersister.getQuerySpaces());
return elem;
}
FromElement createElementJoin(QueryableCollection queryableCollection) throws SemanticException {
FromElement elem;
implied =
true; // TODO: always true for now, but not if we later decide to support elements() in the
// from clause
inElementsFunction = true;
Type elementType = queryableCollection.getElementType();
if (!elementType.isEntityType()) {
throw new IllegalArgumentException(
"Cannot create element join for a collection of non-entities!");
}
this.queryableCollection = queryableCollection;
SessionFactoryHelper sfh = fromClause.getSessionFactoryHelper();
FromElement destination = null;
String tableAlias = null;
EntityPersister entityPersister = queryableCollection.getElementPersister();
tableAlias = fromClause.getAliasGenerator().createName(entityPersister.getEntityName());
String associatedEntityName = entityPersister.getEntityName();
EntityPersister targetEntityPersister = sfh.requireClassPersister(associatedEntityName);
// Create the FROM element for the target (the elements of the collection).
destination =
createAndAddFromElement(
associatedEntityName,
classAlias,
targetEntityPersister,
(EntityType) queryableCollection.getElementType(),
tableAlias);
// If the join is implied, then don't include sub-classes on the element.
if (implied) {
destination.setIncludeSubclasses(false);
}
fromClause.addCollectionJoinFromElementByPath(path, destination);
// origin.addDestination(destination);
// Add the query spaces.
fromClause.getWalker().addQuerySpaces(entityPersister.getQuerySpaces());
CollectionType type = queryableCollection.getCollectionType();
String role = type.getRole();
String roleAlias = origin.getTableAlias();
String[] targetColumns = sfh.getCollectionElementColumns(role, roleAlias);
AssociationType elementAssociationType = sfh.getElementAssociationType(type);
// Create the join element under the from element.
int joinType = JoinFragment.INNER_JOIN;
JoinSequence joinSequence =
sfh.createJoinSequence(
implied, elementAssociationType, tableAlias, joinType, targetColumns);
elem = initializeJoin(path, destination, joinSequence, targetColumns, origin, false);
elem.setUseFromFragment(
true); // The associated entity is implied, but it must be included in the FROM.
elem.setCollectionTableAlias(roleAlias); // The collection alias is the role.
return elem;
}
public FromElement createEntityJoin(
String entityClass,
String tableAlias,
JoinSequence joinSequence,
boolean fetchFlag,
boolean inFrom,
EntityType type,
String role,
String joinPath)
throws SemanticException {
FromElement elem = createJoin(entityClass, tableAlias, joinSequence, type, false);
elem.setFetch(fetchFlag);
if (joinPath != null) {
elem.applyTreatAsDeclarations(fromClause.getWalker().getTreatAsDeclarationsByPath(joinPath));
}
EntityPersister entityPersister = elem.getEntityPersister();
int numberOfTables = entityPersister.getQuerySpaces().length;
if (numberOfTables > 1 && implied && !elem.useFromFragment()) {
LOG.debug("createEntityJoin() : Implied multi-table entity join");
elem.setUseFromFragment(true);
}
// If this is an implied join in a FROM clause, then use ANSI-style joining, and set the
// flag on the FromElement that indicates that it was implied in the FROM clause itself.
if (implied && inFrom) {
joinSequence.setUseThetaStyle(false);
elem.setUseFromFragment(true);
elem.setImpliedInFromClause(true);
}
if (elem.getWalker().isSubQuery()) {
// two conditions where we need to transform this to a theta-join syntax:
// 1) 'elem' is the "root from-element" in correlated subqueries
// 2) The DotNode.useThetaStyleImplicitJoins has been set to true
// and 'elem' represents an implicit join
if (elem.getFromClause() != elem.getOrigin().getFromClause()
||
// ( implied && DotNode.useThetaStyleImplicitJoins ) ) {
PathSeparatorNode.useThetaStyleImplicitJoins) {
// the "root from-element" in correlated subqueries do need this piece
elem.setType(FROM_FRAGMENT);
joinSequence.setUseThetaStyle(true);
elem.setUseFromFragment(false);
}
}
elem.setRole(role);
return elem;
}