private FromElement createManyToMany(
String role,
String associatedEntityName,
String roleAlias,
Queryable entityPersister,
EntityType type,
int joinType)
throws SemanticException {
FromElement elem;
SessionFactoryHelper sfh = fromClause.getSessionFactoryHelper();
if (inElementsFunction /*implied*/) {
// For implied many-to-many, just add the end join.
JoinSequence joinSequence = createJoinSequence(roleAlias, joinType);
elem = createJoin(associatedEntityName, roleAlias, joinSequence, type, true);
} else {
// For an explicit many-to-many relationship, add a second join from the intermediate
// (many-to-many) table to the destination table. Also, make sure that the from element's
// idea of the destination is the destination table.
String tableAlias =
fromClause.getAliasGenerator().createName(entityPersister.getEntityName());
String[] secondJoinColumns = sfh.getCollectionElementColumns(role, roleAlias);
// Add the second join, the one that ends in the destination table.
JoinSequence joinSequence = createJoinSequence(roleAlias, joinType);
joinSequence.addJoin(
sfh.getElementAssociationType(collectionType), tableAlias, joinType, secondJoinColumns);
elem = createJoin(associatedEntityName, tableAlias, joinSequence, type, false);
elem.setUseFromFragment(true);
}
return elem;
}
public String addFromCollection(QueryTranslatorImpl q) throws QueryException {
Type collectionElementType = getPropertyType();
if (collectionElementType == null) {
throw new QueryException(
"must specify 'elements' for collection valued property in from clause: " + path);
}
if (collectionElementType.isEntityType()) {
// an association
QueryableCollection collectionPersister = q.getCollectionPersister(collectionRole);
Queryable entityPersister = (Queryable) collectionPersister.getElementPersister();
String clazz = entityPersister.getEntityName();
final String elementName;
if (collectionPersister.isOneToMany()) {
elementName = collectionName;
// allow index() function:
q.decoratePropertyMapping(elementName, collectionPersister);
} else { // many-to-many
q.addCollection(collectionName, collectionRole);
elementName = q.createNameFor(clazz);
addJoin(elementName, (AssociationType) collectionElementType);
}
q.addFrom(elementName, clazz, joinSequence);
currentPropertyMapping = new CollectionPropertyMapping(collectionPersister);
return elementName;
} else {
// collections of values
q.addFromCollection(collectionName, collectionRole, joinSequence);
return collectionName;
}
}
protected AST createIntoClause(String path, AST propertySpec) throws SemanticException {
Queryable persister = (Queryable) getSessionFactoryHelper().requireClassPersister(path);
IntoClause intoClause = (IntoClause) getASTFactory().create(INTO, persister.getEntityName());
intoClause.setFirstChild(propertySpec);
intoClause.initialize(persister);
addQuerySpaces(persister.getQuerySpaces());
return intoClause;
}
protected String generateIdInsertSelect(Queryable persister, String tableAlias, AST whereClause) {
Select select = new Select(getFactory().getDialect());
SelectFragment selectFragment =
new SelectFragment()
.addColumns(
tableAlias,
persister.getIdentifierColumnNames(),
persister.getIdentifierColumnNames());
select.setSelectClause(selectFragment.toFragmentString().substring(2));
String rootTableName = persister.getTableName();
String fromJoinFragment = persister.fromJoinFragment(tableAlias, true, false);
String whereJoinFragment = persister.whereJoinFragment(tableAlias, true, false);
select.setFromClause(rootTableName + ' ' + tableAlias + fromJoinFragment);
if (whereJoinFragment == null) {
whereJoinFragment = "";
} else {
whereJoinFragment = whereJoinFragment.trim();
if (whereJoinFragment.startsWith("and")) {
whereJoinFragment = whereJoinFragment.substring(4);
}
}
String userWhereClause = "";
if (whereClause.getNumberOfChildren() != 0) {
// If a where clause was specified in the update/delete query, use it to limit the
// returned ids here...
try {
SqlGenerator sqlGenerator = new SqlGenerator(getFactory());
sqlGenerator.whereClause(whereClause);
userWhereClause = sqlGenerator.getSQL().substring(7); // strip the " where "
} catch (RecognitionException e) {
throw new HibernateException("Unable to generate id select for DML operation", e);
}
if (whereJoinFragment.length() > 0) {
whereJoinFragment += " and ";
}
}
select.setWhereClause(whereJoinFragment + userWhereClause);
InsertSelect insert = new InsertSelect(getFactory().getDialect());
if (getFactory().getSettings().isCommentsEnabled()) {
insert.setComment("insert-select for " + persister.getEntityName() + " ids");
}
insert.setTableName(persister.getTemporaryIdTableName());
insert.setSelect(select);
return insert.toStatementString();
}
private FromElement createEntityAssociation(String role, String roleAlias, int joinType)
throws SemanticException {
FromElement elem;
Queryable entityPersister = (Queryable) queryableCollection.getElementPersister();
String associatedEntityName = entityPersister.getEntityName();
// Get the class name of the associated entity.
if (queryableCollection.isOneToMany()) {
if (log.isDebugEnabled()) {
log.debug(
"createEntityAssociation() : One to many - path = "
+ path
+ " role = "
+ role
+ " associatedEntityName = "
+ associatedEntityName);
}
JoinSequence joinSequence = createJoinSequence(roleAlias, joinType);
elem =
createJoin(
associatedEntityName,
roleAlias,
joinSequence,
(EntityType) queryableCollection.getElementType(),
false);
} else {
if (log.isDebugEnabled()) {
log.debug(
"createManyToMany() : path = "
+ path
+ " role = "
+ role
+ " associatedEntityName = "
+ associatedEntityName);
}
elem =
createManyToMany(
role,
associatedEntityName,
roleAlias,
entityPersister,
(EntityType) queryableCollection.getElementType(),
joinType);
fromClause.getWalker().addQuerySpaces(queryableCollection.getCollectionSpaces());
}
elem.setCollectionTableAlias(roleAlias);
return elem;
}
/**
* Return the names of all persistent (mapped) classes that extend or implement the given class or
* interface, accounting for implicit/explicit polymorphism settings and excluding mapped
* subclasses/joined-subclasses of other classes in the result.
*/
public String[] getImplementors(String className) throws MappingException {
final Class clazz;
try {
clazz = ReflectHelper.classForName(className);
} catch (ClassNotFoundException cnfe) {
return new String[] {className}; // for a dynamic-class
}
ArrayList results = new ArrayList();
Iterator iter = entityPersisters.values().iterator();
while (iter.hasNext()) {
// test this entity to see if we must query it
EntityPersister testPersister = (EntityPersister) iter.next();
if (testPersister instanceof Queryable) {
Queryable testQueryable = (Queryable) testPersister;
String testClassName = testQueryable.getEntityName();
boolean isMappedClass = className.equals(testClassName);
if (testQueryable.isExplicitPolymorphism()) {
if (isMappedClass) {
return new String[] {className}; // NOTE EARLY EXIT
}
} else {
if (isMappedClass) {
results.add(testClassName);
} else {
final Class mappedClass = testQueryable.getMappedClass(EntityMode.POJO);
if (mappedClass != null && clazz.isAssignableFrom(mappedClass)) {
final boolean assignableSuperclass;
if (testQueryable.isInherited()) {
Class mappedSuperclass =
getEntityPersister(testQueryable.getMappedSuperclass())
.getMappedClass(EntityMode.POJO);
assignableSuperclass = clazz.isAssignableFrom(mappedSuperclass);
} else {
assignableSuperclass = false;
}
if (!assignableSuperclass) {
results.add(testClassName);
}
}
}
}
}
}
return (String[]) results.toArray(new String[results.size()]);
}
private String getPathEntityName(String path) {
Queryable persister = (Queryable) sessionFactory.getEntityPersister(rootEntityName);
StringTokenizer tokens = new StringTokenizer(path, ".");
String componentPath = "";
while (tokens.hasMoreTokens()) {
componentPath += tokens.nextToken();
Type type = persister.toType(componentPath);
if (type.isAssociationType()) {
AssociationType atype = (AssociationType) type;
persister =
(Queryable)
sessionFactory.getEntityPersister(atype.getAssociatedEntityName(sessionFactory));
componentPath = "";
} else if (type.isComponentType()) {
componentPath += '.';
} else {
throw new QueryException("not an association: " + componentPath);
}
}
return persister.getEntityName();
}
public CustomLoader(CustomQuery customQuery, SessionFactoryImplementor factory) {
super(factory);
this.sql = customQuery.getSQL();
this.querySpaces.addAll(customQuery.getQuerySpaces());
this.namedParameterBindPoints = customQuery.getNamedParameterBindPoints();
List entityPersisters = new ArrayList();
List entityOwners = new ArrayList();
List entityAliases = new ArrayList();
List collectionPersisters = new ArrayList();
List collectionOwners = new ArrayList();
List collectionAliases = new ArrayList();
List lockModes = new ArrayList();
List resultColumnProcessors = new ArrayList();
List nonScalarReturnList = new ArrayList();
List resultTypes = new ArrayList();
List specifiedAliases = new ArrayList();
int returnableCounter = 0;
boolean hasScalars = false;
List includeInResultRowList = new ArrayList();
Iterator itr = customQuery.getCustomQueryReturns().iterator();
while (itr.hasNext()) {
final Return rtn = (Return) itr.next();
if (rtn instanceof ScalarReturn) {
ScalarReturn scalarRtn = (ScalarReturn) rtn;
resultTypes.add(scalarRtn.getType());
specifiedAliases.add(scalarRtn.getColumnAlias());
resultColumnProcessors.add(
new ScalarResultColumnProcessor(
StringHelper.unquote(scalarRtn.getColumnAlias(), factory.getDialect()),
scalarRtn.getType()));
includeInResultRowList.add(true);
hasScalars = true;
} else if (ConstructorReturn.class.isInstance(rtn)) {
final ConstructorReturn constructorReturn = (ConstructorReturn) rtn;
resultTypes.add(null); // this bit makes me nervous
includeInResultRowList.add(true);
hasScalars = true;
ScalarResultColumnProcessor[] scalarProcessors =
new ScalarResultColumnProcessor[constructorReturn.getScalars().length];
int i = 0;
for (ScalarReturn scalarReturn : constructorReturn.getScalars()) {
scalarProcessors[i++] =
new ScalarResultColumnProcessor(
StringHelper.unquote(scalarReturn.getColumnAlias(), factory.getDialect()),
scalarReturn.getType());
}
resultColumnProcessors.add(
new ConstructorResultColumnProcessor(
constructorReturn.getTargetClass(), scalarProcessors));
} else if (rtn instanceof RootReturn) {
RootReturn rootRtn = (RootReturn) rtn;
Queryable persister = (Queryable) factory.getEntityPersister(rootRtn.getEntityName());
entityPersisters.add(persister);
lockModes.add((rootRtn.getLockMode()));
resultColumnProcessors.add(new NonScalarResultColumnProcessor(returnableCounter++));
nonScalarReturnList.add(rtn);
entityOwners.add(-1);
resultTypes.add(persister.getType());
specifiedAliases.add(rootRtn.getAlias());
entityAliases.add(rootRtn.getEntityAliases());
ArrayHelper.addAll(querySpaces, persister.getQuerySpaces());
includeInResultRowList.add(true);
} else if (rtn instanceof CollectionReturn) {
CollectionReturn collRtn = (CollectionReturn) rtn;
String role = collRtn.getOwnerEntityName() + "." + collRtn.getOwnerProperty();
QueryableCollection persister = (QueryableCollection) factory.getCollectionPersister(role);
collectionPersisters.add(persister);
lockModes.add(collRtn.getLockMode());
resultColumnProcessors.add(new NonScalarResultColumnProcessor(returnableCounter++));
nonScalarReturnList.add(rtn);
collectionOwners.add(-1);
resultTypes.add(persister.getType());
specifiedAliases.add(collRtn.getAlias());
collectionAliases.add(collRtn.getCollectionAliases());
// determine if the collection elements are entities...
Type elementType = persister.getElementType();
if (elementType.isEntityType()) {
Queryable elementPersister =
(Queryable) ((EntityType) elementType).getAssociatedJoinable(factory);
entityPersisters.add(elementPersister);
entityOwners.add(-1);
entityAliases.add(collRtn.getElementEntityAliases());
ArrayHelper.addAll(querySpaces, elementPersister.getQuerySpaces());
}
includeInResultRowList.add(true);
} else if (rtn instanceof EntityFetchReturn) {
EntityFetchReturn fetchRtn = (EntityFetchReturn) rtn;
NonScalarReturn ownerDescriptor = fetchRtn.getOwner();
int ownerIndex = nonScalarReturnList.indexOf(ownerDescriptor);
entityOwners.add(ownerIndex);
lockModes.add(fetchRtn.getLockMode());
Queryable ownerPersister = determineAppropriateOwnerPersister(ownerDescriptor);
EntityType fetchedType =
(EntityType) ownerPersister.getPropertyType(fetchRtn.getOwnerProperty());
String entityName = fetchedType.getAssociatedEntityName(getFactory());
Queryable persister = (Queryable) factory.getEntityPersister(entityName);
entityPersisters.add(persister);
nonScalarReturnList.add(rtn);
specifiedAliases.add(fetchRtn.getAlias());
entityAliases.add(fetchRtn.getEntityAliases());
ArrayHelper.addAll(querySpaces, persister.getQuerySpaces());
includeInResultRowList.add(false);
} else if (rtn instanceof CollectionFetchReturn) {
CollectionFetchReturn fetchRtn = (CollectionFetchReturn) rtn;
NonScalarReturn ownerDescriptor = fetchRtn.getOwner();
int ownerIndex = nonScalarReturnList.indexOf(ownerDescriptor);
collectionOwners.add(ownerIndex);
lockModes.add(fetchRtn.getLockMode());
Queryable ownerPersister = determineAppropriateOwnerPersister(ownerDescriptor);
String role = ownerPersister.getEntityName() + '.' + fetchRtn.getOwnerProperty();
QueryableCollection persister = (QueryableCollection) factory.getCollectionPersister(role);
collectionPersisters.add(persister);
nonScalarReturnList.add(rtn);
specifiedAliases.add(fetchRtn.getAlias());
collectionAliases.add(fetchRtn.getCollectionAliases());
// determine if the collection elements are entities...
Type elementType = persister.getElementType();
if (elementType.isEntityType()) {
Queryable elementPersister =
(Queryable) ((EntityType) elementType).getAssociatedJoinable(factory);
entityPersisters.add(elementPersister);
entityOwners.add(ownerIndex);
entityAliases.add(fetchRtn.getElementEntityAliases());
ArrayHelper.addAll(querySpaces, elementPersister.getQuerySpaces());
}
includeInResultRowList.add(false);
} else {
throw new HibernateException(
"unexpected custom query return type : " + rtn.getClass().getName());
}
}
this.entityPersisters = new Queryable[entityPersisters.size()];
for (int i = 0; i < entityPersisters.size(); i++) {
this.entityPersisters[i] = (Queryable) entityPersisters.get(i);
}
this.entiytOwners = ArrayHelper.toIntArray(entityOwners);
this.entityAliases = new EntityAliases[entityAliases.size()];
for (int i = 0; i < entityAliases.size(); i++) {
this.entityAliases[i] = (EntityAliases) entityAliases.get(i);
}
this.collectionPersisters = new QueryableCollection[collectionPersisters.size()];
for (int i = 0; i < collectionPersisters.size(); i++) {
this.collectionPersisters[i] = (QueryableCollection) collectionPersisters.get(i);
}
this.collectionOwners = ArrayHelper.toIntArray(collectionOwners);
this.collectionAliases = new CollectionAliases[collectionAliases.size()];
for (int i = 0; i < collectionAliases.size(); i++) {
this.collectionAliases[i] = (CollectionAliases) collectionAliases.get(i);
}
this.lockModes = new LockMode[lockModes.size()];
for (int i = 0; i < lockModes.size(); i++) {
this.lockModes[i] = (LockMode) lockModes.get(i);
}
this.resultTypes = ArrayHelper.toTypeArray(resultTypes);
this.transformerAliases = ArrayHelper.toStringArray(specifiedAliases);
this.rowProcessor =
new ResultRowProcessor(
hasScalars,
(ResultColumnProcessor[])
resultColumnProcessors.toArray(
new ResultColumnProcessor[resultColumnProcessors.size()]));
this.includeInResultRow = ArrayHelper.toBooleanArray(includeInResultRowList);
}
void addFromClass(String name, Queryable classPersister) throws QueryException {
JoinSequence joinSequence = new JoinSequence(getFactory()).setRoot(classPersister, name);
// crossJoins.add(name);
addFrom(name, classPersister.getEntityName(), joinSequence);
}
