HHH-15944 Joins on non-managed-type polymorphisms don't work

This commit is contained in:
Andrea Boriero 2023-01-20 21:23:51 +01:00 committed by Christian Beikov
parent 1aa4f177b0
commit 26ef29bb0d
19 changed files with 533 additions and 60 deletions

View File

@ -22,10 +22,31 @@ import org.hibernate.query.criteria.JpaSearchOrder;
import org.hibernate.query.sqm.tree.SqmQuery;
import org.hibernate.query.sqm.tree.cte.SqmCteTableColumn;
import org.hibernate.query.sqm.tree.cte.SqmSearchClauseSpecification;
import org.hibernate.query.sqm.tree.domain.SqmBagJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedBagJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedCrossJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedEntityJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedListJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedMapJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedPluralPartJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedRoot;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedRootJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedSetJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedSingularJoin;
import org.hibernate.query.sqm.tree.domain.SqmCteRoot;
import org.hibernate.query.sqm.tree.domain.SqmDerivedRoot;
import org.hibernate.query.sqm.tree.domain.SqmListJoin;
import org.hibernate.query.sqm.tree.domain.SqmMapJoin;
import org.hibernate.query.sqm.tree.domain.SqmSetJoin;
import org.hibernate.query.sqm.tree.domain.SqmSingularJoin;
import org.hibernate.query.sqm.tree.domain.SqmTreatedPath;
import org.hibernate.query.sqm.tree.domain.SqmTreatedRoot;
import org.hibernate.query.sqm.tree.domain.SqmTreatedSimplePath;
import org.hibernate.query.sqm.tree.expression.SqmAny;
import org.hibernate.query.sqm.tree.expression.SqmEvery;
import org.hibernate.query.sqm.tree.from.SqmCteJoin;
import org.hibernate.query.sqm.tree.from.SqmDerivedJoin;
import org.hibernate.query.sqm.tree.from.SqmJoin;
import org.hibernate.query.sqm.tree.select.SqmSelectQuery;
import org.hibernate.spi.NavigablePath;
import org.hibernate.query.hql.spi.SqmCreationOptions;
@ -54,7 +75,6 @@ import org.hibernate.query.sqm.tree.expression.SqmLiteralEntityType;
import org.hibernate.query.sqm.tree.expression.SqmNamedParameter;
import org.hibernate.query.sqm.tree.expression.SqmPositionalParameter;
import org.hibernate.query.sqm.tree.expression.SqmUnaryOperation;
import org.hibernate.query.sqm.tree.from.SqmAttributeJoin;
import org.hibernate.query.sqm.tree.from.SqmCrossJoin;
import org.hibernate.query.sqm.tree.from.SqmEntityJoin;
import org.hibernate.query.sqm.tree.from.SqmFrom;
@ -190,8 +210,8 @@ public class QuerySplitter {
private final SqmCreationContext creationContext;
private final Stack<SqmCreationProcessingState> processingStateStack = new StandardStack<>( SqmCreationProcessingState.class );
private Map<NavigablePath, SqmPath> sqmPathCopyMap = new HashMap<>();
private Map<SqmFrom, SqmFrom> sqmFromCopyMap = new HashMap<>();
private final Map<NavigablePath, SqmPath> sqmPathCopyMap = new HashMap<>();
private final Map<SqmFrom, SqmFrom> sqmFromCopyMap = new HashMap<>();
private UnmappedPolymorphismReplacer(
SqmRoot unmappedPolymorphicFromElement,
@ -598,16 +618,28 @@ public class QuerySplitter {
if ( sqmFrom != null ) {
return (SqmCrossJoin<?>) sqmFrom;
}
final SqmRoot<?> sqmRoot = (SqmRoot<?>) sqmFromCopyMap.get( join.findRoot() );
final SqmCrossJoin copy = new SqmCrossJoin<>(
join.getReferencedPathSource(),
join.getExplicitAlias(),
sqmRoot
(SqmRoot<?>) sqmFromCopyMap.get( join.findRoot() )
);
getProcessingStateStack().getCurrent().getPathRegistry().register( copy );
sqmFromCopyMap.put( join, copy );
sqmPathCopyMap.put( join.getNavigablePath(), copy );
sqmRoot.addSqmJoin( copy );
visitJoins( join, copy );
return copy;
}
@Override
public SqmCorrelatedCrossJoin<?> visitCorrelatedCrossJoin(SqmCorrelatedCrossJoin<?> join) {
final SqmFrom<?, ?> sqmFrom = sqmFromCopyMap.get( join );
if ( sqmFrom != null ) {
return (SqmCorrelatedCrossJoin<?>) sqmFrom;
}
final SqmCorrelatedCrossJoin copy = new SqmCorrelatedCrossJoin<>(
findSqmFromCopy( join.getCorrelationParent() )
);
visitJoins( join, copy );
return copy;
}
@ -617,18 +649,29 @@ public class QuerySplitter {
if ( sqmFrom != null ) {
return (SqmPluralPartJoin<?, ?>) sqmFrom;
}
final SqmFrom<?, ?> newLhs = (SqmFrom<?, ?>) sqmFromCopyMap.get( join.getLhs() );
final SqmPluralPartJoin copy = new SqmPluralPartJoin<>(
newLhs,
(SqmFrom<?, ?>) sqmFromCopyMap.get( join.getLhs() ),
join.getReferencedPathSource(),
join.getExplicitAlias(),
join.getSqmJoinType(),
join.nodeBuilder()
);
getProcessingStateStack().getCurrent().getPathRegistry().register( copy );
sqmFromCopyMap.put( join, copy );
sqmPathCopyMap.put( join.getNavigablePath(), copy );
newLhs.addSqmJoin( copy );
visitJoins( join, copy );
return copy;
}
@Override
public SqmCorrelatedPluralPartJoin<?,?> visitCorrelatedPluralPartJoin(SqmCorrelatedPluralPartJoin<?, ?> join) {
final SqmFrom<?, ?> sqmFrom = sqmFromCopyMap.get( join );
if ( sqmFrom != null ) {
return (SqmCorrelatedPluralPartJoin<?, ?>) sqmFrom;
}
final SqmCorrelatedPluralPartJoin copy = new SqmCorrelatedPluralPartJoin<>(
findSqmFromCopy( join.getCorrelationParent() )
);
visitJoins( join, copy );
return copy;
}
@ -645,24 +688,235 @@ public class QuerySplitter {
join.getSqmJoinType(),
sqmRoot
);
getProcessingStateStack().getCurrent().getPathRegistry().register( copy );
sqmFromCopyMap.put( join, copy );
sqmPathCopyMap.put( join.getNavigablePath(), copy );
sqmRoot.addSqmJoin( copy );
visitJoins( join, copy );
return copy;
}
@Override
public SqmAttributeJoin<?, ?> visitQualifiedAttributeJoin(SqmAttributeJoin<?, ?> join) {
SqmFrom<?, ?> sqmFrom = sqmFromCopyMap.get( join );
public SqmCorrelatedRootJoin<?> visitCorrelatedRootJoin(SqmCorrelatedRootJoin<?> correlatedRootJoin) {
final SqmCorrelatedRootJoin<?> sqmFrom = (SqmCorrelatedRootJoin<?>) sqmFromCopyMap.get( correlatedRootJoin );
if ( sqmFrom != null ) {
return (SqmAttributeJoin<?, ?>) sqmFrom;
return sqmFrom;
}
SqmAttributeJoin copy = join.makeCopy( getProcessingStateStack().getCurrent() );
getProcessingStateStack().getCurrent().getPathRegistry().register( copy );
sqmFromCopyMap.put( join, copy );
sqmPathCopyMap.put( join.getNavigablePath(), copy );
( (SqmFrom<?, ?>) copy.getParent() ).addSqmJoin( copy );
SqmCorrelatedRootJoin<?> copy = new SqmCorrelatedRootJoin<>(
correlatedRootJoin.getNavigablePath(),
correlatedRootJoin.getReferencedPathSource(),
correlatedRootJoin.nodeBuilder()
);
correlatedRootJoin.visitReusablePaths( path -> path.accept( this ) );
sqmFromCopyMap.put( correlatedRootJoin, copy );
sqmPathCopyMap.put( correlatedRootJoin.getNavigablePath(), copy );
correlatedRootJoin.visitSqmJoins(
sqmJoin ->
sqmJoin.accept( this )
);
return copy;
}
@Override
public SqmCorrelatedRoot<?> visitCorrelatedRoot(SqmCorrelatedRoot<?> correlatedRoot) {
final SqmCorrelatedRoot<?> sqmFrom = (SqmCorrelatedRoot<?>) sqmFromCopyMap.get( correlatedRoot );
if ( sqmFrom != null ) {
return sqmFrom;
}
SqmCorrelatedRoot<?> copy = new SqmCorrelatedRoot<>(
findSqmFromCopy( correlatedRoot.getCorrelationParent() )
);
correlatedRoot.visitReusablePaths( path -> path.accept( this ) );
sqmFromCopyMap.put( correlatedRoot, copy );
sqmPathCopyMap.put( correlatedRoot.getNavigablePath(), copy );
correlatedRoot.visitSqmJoins(
sqmJoin ->
sqmJoin.accept( this )
);
return copy;
}
@Override
public SqmBagJoin<?, ?> visitBagJoin(SqmBagJoin<?, ?> join) {
final SqmFrom<?, ?> existing = sqmFromCopyMap.get( join );
if ( existing != null ) {
return (SqmBagJoin<?, ?>) existing;
}
final SqmBagJoin copy = new SqmBagJoin<>(
findSqmFromCopy( join.getLhs() ),
join.getReferencedPathSource(),
join.getExplicitAlias(),
join.getSqmJoinType(),
join.isFetched(),
join.nodeBuilder()
);
visitJoins( join, copy );
return copy;
}
@Override
public SqmCorrelatedBagJoin<?, ?> visitCorrelatedBagJoin(SqmCorrelatedBagJoin<?, ?> join) {
final SqmFrom<?, ?> existing = sqmFromCopyMap.get( join );
if ( existing != null ) {
return (SqmCorrelatedBagJoin<?, ?>) existing;
}
final SqmCorrelatedBagJoin copy = new SqmCorrelatedBagJoin<>(
findSqmFromCopy( join.getCorrelationParent() )
);
visitJoins( join, copy );
return copy;
}
@Override
public SqmCorrelatedListJoin<?, ?> visitCorrelatedListJoin(SqmCorrelatedListJoin<?, ?> join) {
final SqmFrom<?, ?> existing = sqmFromCopyMap.get( join );
if ( existing != null ) {
return (SqmCorrelatedListJoin<?, ?>) existing;
}
final SqmCorrelatedListJoin copy = new SqmCorrelatedListJoin<>(
findSqmFromCopy( join.getCorrelationParent() )
);
visitJoins( join, copy );
return copy;
}
@Override
public SqmCorrelatedMapJoin<?, ?, ?> visitCorrelatedMapJoin(SqmCorrelatedMapJoin<?, ?, ?> join) {
final SqmFrom<?, ?> existing = sqmFromCopyMap.get( join );
if ( existing != null ) {
return (SqmCorrelatedMapJoin<?, ?, ?>) existing;
}
final SqmCorrelatedMapJoin copy = new SqmCorrelatedMapJoin<>(
findSqmFromCopy( join.getCorrelationParent() )
);
visitJoins( join, copy );
return copy;
}
@Override
public SqmCorrelatedSetJoin<?, ?> visitCorrelatedSetJoin(SqmCorrelatedSetJoin<?, ?> join) {
final SqmFrom<?, ?> existing = sqmFromCopyMap.get( join );
if ( existing != null ) {
return (SqmCorrelatedSetJoin<?, ?>) existing;
}
final SqmCorrelatedSetJoin copy = new SqmCorrelatedSetJoin<>(
findSqmFromCopy( join.getCorrelationParent() )
);
visitJoins( join, copy );
return copy;
}
@Override
public SqmCorrelatedSingularJoin<?, ?> visitCorrelatedSingularJoin(SqmCorrelatedSingularJoin<?, ?> join) {
final SqmFrom<?, ?> existing = sqmFromCopyMap.get( join );
if ( existing != null ) {
return (SqmCorrelatedSingularJoin<?, ?>) existing;
}
final SqmCorrelatedSingularJoin copy = new SqmCorrelatedSingularJoin<>(
findSqmFromCopy( join.getCorrelationParent() )
);
visitJoins( join, copy );
return copy;
}
@Override
public SqmListJoin<?, ?> visitListJoin(SqmListJoin<?, ?> join) {
final SqmFrom<?, ?> existing = sqmFromCopyMap.get( join );
if ( existing != null ) {
return (SqmListJoin<?, ?>) existing;
}
final SqmListJoin copy = new SqmListJoin<>(
findSqmFromCopy( join.getLhs() ),
join.getReferencedPathSource(),
join.getExplicitAlias(),
join.getSqmJoinType(),
join.isFetched(),
join.nodeBuilder()
);
visitJoins( join, copy );
return copy;
}
@Override
public SqmMapJoin<?, ?, ?> visitMapJoin(SqmMapJoin<?, ?, ?> join) {
final SqmFrom<?, ?> existing = sqmFromCopyMap.get( join );
if ( existing != null ) {
return (SqmMapJoin<?, ?, ?>) existing;
}
final SqmMapJoin copy = new SqmMapJoin<>(
findSqmFromCopy( join.getLhs() ),
join.getReferencedPathSource(),
join.getExplicitAlias(),
join.getSqmJoinType(),
join.isFetched(),
join.nodeBuilder()
);
visitJoins( join, copy );
return copy;
}
@Override
public SqmSetJoin<?, ?> visitSetJoin(SqmSetJoin<?, ?> join) {
final SqmFrom<?, ?> existing = sqmFromCopyMap.get( join );
if ( existing != null ) {
return (SqmSetJoin<?, ?>) existing;
}
final SqmSetJoin copy = new SqmSetJoin<>(
findSqmFromCopy( join.getLhs() ),
join.getReferencedPathSource(),
join.getExplicitAlias(),
join.getSqmJoinType(),
join.isFetched(),
join.nodeBuilder()
);
visitJoins( join, copy );
return copy;
}
@Override
public SqmSingularJoin<?, ?> visitSingularJoin(SqmSingularJoin<?, ?> join) {
final SqmFrom<?, ?> existing = sqmFromCopyMap.get( join );
if ( existing != null ) {
return (SqmSingularJoin<?, ?>) existing;
}
final SqmSingularJoin copy = new SqmSingularJoin<>(
findSqmFromCopy( join.getLhs() ),
join.getReferencedPathSource(),
join.getExplicitAlias(),
join.getSqmJoinType(),
join.isFetched(),
join.nodeBuilder()
);
visitJoins( join, copy );
return copy;
}
@ -680,10 +934,23 @@ public class QuerySplitter {
join.isLateral(),
sqmRoot
);
getProcessingStateStack().getCurrent().getPathRegistry().register( copy );
sqmFromCopyMap.put( join, copy );
sqmPathCopyMap.put( join.getNavigablePath(), copy );
sqmRoot.addSqmJoin( copy );
visitJoins( join, copy );
return copy;
}
@Override
public SqmCorrelatedEntityJoin<?> visitCorrelatedEntityJoin(SqmCorrelatedEntityJoin<?> join) {
SqmFrom<?, ?> sqmFrom = sqmFromCopyMap.get( join );
if ( sqmFrom != null ) {
return (SqmCorrelatedEntityJoin<?>) sqmFrom;
}
final SqmCorrelatedEntityJoin copy = new SqmCorrelatedEntityJoin(
findSqmFromCopy( join.getCorrelationParent() )
);
visitJoins( join, copy );
return copy;
}
@ -700,10 +967,8 @@ public class QuerySplitter {
join.getSqmJoinType(),
sqmRoot
);
getProcessingStateStack().getCurrent().getPathRegistry().register( copy );
sqmFromCopyMap.put( join, copy );
sqmPathCopyMap.put( join.getNavigablePath(), copy );
sqmRoot.addSqmJoin( copy );
visitJoins( join, copy );
return copy;
}
@ -711,7 +976,7 @@ public class QuerySplitter {
public SqmBasicValuedSimplePath<?> visitBasicValuedPath(SqmBasicValuedSimplePath<?> path) {
final SqmPathRegistry pathRegistry = getProcessingStateStack().getCurrent().getPathRegistry();
final SqmPath<?> lhs = findLhs( path, pathRegistry );
final SqmPath<?> lhs = findLhs( path );
final SqmBasicValuedSimplePath<?> copy = new SqmBasicValuedSimplePath<>(
lhs.getNavigablePath().append( path.getNavigablePath().getLocalName() ),
@ -728,7 +993,7 @@ public class QuerySplitter {
@Override
public SqmEmbeddedValuedSimplePath<?> visitEmbeddableValuedPath(SqmEmbeddedValuedSimplePath<?> path) {
final SqmPathRegistry pathRegistry = getProcessingStateStack().getCurrent().getPathRegistry();
final SqmPath<?> lhs = findLhs( path, pathRegistry );
final SqmPath<?> lhs = findLhs( path );
final SqmEmbeddedValuedSimplePath<?> copy = new SqmEmbeddedValuedSimplePath<>(
lhs.getNavigablePath().append( path.getNavigablePath().getLocalName() ),
path.getReferencedPathSource(),
@ -743,7 +1008,7 @@ public class QuerySplitter {
@Override
public SqmEntityValuedSimplePath<?> visitEntityValuedPath(SqmEntityValuedSimplePath<?> path) {
final SqmPathRegistry pathRegistry = getProcessingStateStack().getCurrent().getPathRegistry();
final SqmPath<?> lhs = findLhs( path, pathRegistry );
final SqmPath<?> lhs = findLhs( path );
final SqmEntityValuedSimplePath<?> copy = new SqmEntityValuedSimplePath<>(
lhs.getNavigablePath().append( path.getNavigablePath().getLocalName() ),
path.getReferencedPathSource(),
@ -758,7 +1023,7 @@ public class QuerySplitter {
@Override
public SqmPluralValuedSimplePath<?> visitPluralValuedPath(SqmPluralValuedSimplePath<?> path) {
final SqmPathRegistry pathRegistry = getProcessingStateStack().getCurrent().getPathRegistry();
SqmPath<?> lhs = findLhs( path, pathRegistry );
SqmPath<?> lhs = findLhs( path );
final SqmPluralValuedSimplePath<?> copy = new SqmPluralValuedSimplePath<>(
path.getNavigablePath(),
@ -771,11 +1036,11 @@ public class QuerySplitter {
return copy;
}
private SqmPath<?> findLhs(SqmPath<?> path, SqmPathRegistry pathRegistry) {
private SqmPath<?> findLhs(SqmPath<?> path) {
final SqmPath<?> lhs = path.getLhs();
final SqmPath sqmFrom = sqmPathCopyMap.get( lhs.getNavigablePath() );
if ( sqmFrom != null ) {
return pathRegistry.findFromByPath( sqmFrom.getNavigablePath() );
final SqmPath lhsSqmPathCopy = sqmPathCopyMap.get( lhs.getNavigablePath() );
if ( lhsSqmPathCopy != null ) {
return lhsSqmPathCopy;
}
else {
return (SqmPath<?>) lhs.accept( this );
@ -1022,6 +1287,28 @@ public class QuerySplitter {
);
}
@Override
public Object visitAny(SqmAny<?> sqmAny) {
return new SqmAny<>(
(SqmSubQuery<?>) sqmAny.getSubquery().accept( this ),
this.creationContext.getNodeBuilder()
);
}
@Override
public Object visitTreatedPath(SqmTreatedPath<?, ?> sqmTreatedPath) {
throw new UnsupportedOperationException("Polymorphic queries: treat operator is not supported");
}
@Override
public Object visitEvery(SqmEvery<?> sqmEvery) {
sqmEvery.getSubquery().accept( this );
return new SqmEvery<>(
(SqmSubQuery<?>) sqmEvery.getSubquery().accept( this ),
this.creationContext.getNodeBuilder()
);
}
@Override
public Stack<SqmCreationProcessingState> getProcessingStateStack() {
return processingStateStack;
@ -1037,6 +1324,29 @@ public class QuerySplitter {
return () -> false;
}
public <X extends SqmFrom<?, ?>> X findSqmFromCopy(SqmFrom sqmFrom) {
SqmFrom copy = sqmFromCopyMap.get( sqmFrom );
if ( copy != null ) {
return (X) copy;
}
else {
return (X) sqmFrom.accept( this );
}
}
private void visitJoins(SqmFrom<?, ?> join, SqmJoin copy) {
getProcessingStateStack().getCurrent().getPathRegistry().register( copy );
sqmFromCopyMap.put( join, copy );
sqmPathCopyMap.put( join.getNavigablePath(), copy );
join.visitSqmJoins(
sqmJoin ->
sqmJoin.accept( this )
);
SqmFrom<?, ?> lhs = (SqmFrom<?, ?>) copy.getLhs();
if ( lhs != null ) {
lhs.addSqmJoin( copy );
}
}
}
}

View File

@ -15,7 +15,18 @@ import org.hibernate.query.sqm.tree.cte.SqmCteStatement;
import org.hibernate.query.sqm.tree.delete.SqmDeleteStatement;
import org.hibernate.query.sqm.tree.domain.NonAggregatedCompositeSimplePath;
import org.hibernate.query.sqm.tree.domain.SqmAnyValuedSimplePath;
import org.hibernate.query.sqm.tree.domain.SqmBagJoin;
import org.hibernate.query.sqm.tree.domain.SqmBasicValuedSimplePath;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedBagJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedCrossJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedEntityJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedListJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedMapJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedPluralPartJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedRoot;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedRootJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedSetJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelatedSingularJoin;
import org.hibernate.query.sqm.tree.domain.SqmCorrelation;
import org.hibernate.query.sqm.tree.domain.SqmCteRoot;
import org.hibernate.query.sqm.tree.domain.SqmDerivedRoot;
@ -23,11 +34,15 @@ import org.hibernate.query.sqm.tree.domain.SqmEmbeddedValuedSimplePath;
import org.hibernate.query.sqm.tree.domain.SqmEntityValuedSimplePath;
import org.hibernate.query.sqm.tree.domain.SqmFkExpression;
import org.hibernate.query.sqm.tree.domain.SqmIndexedCollectionAccessPath;
import org.hibernate.query.sqm.tree.domain.SqmListJoin;
import org.hibernate.query.sqm.tree.domain.SqmMapEntryReference;
import org.hibernate.query.sqm.tree.domain.SqmElementAggregateFunction;
import org.hibernate.query.sqm.tree.domain.SqmIndexAggregateFunction;
import org.hibernate.query.sqm.tree.domain.SqmMapJoin;
import org.hibernate.query.sqm.tree.domain.SqmPluralPartJoin;
import org.hibernate.query.sqm.tree.domain.SqmPluralValuedSimplePath;
import org.hibernate.query.sqm.tree.domain.SqmSetJoin;
import org.hibernate.query.sqm.tree.domain.SqmSingularJoin;
import org.hibernate.query.sqm.tree.domain.SqmTreatedPath;
import org.hibernate.query.sqm.tree.expression.JpaCriteriaParameter;
import org.hibernate.query.sqm.tree.expression.SqmAny;
@ -147,6 +162,58 @@ public interface SemanticQueryWalker<T> {
T visitQualifiedAttributeJoin(SqmAttributeJoin<?, ?> joinedFromElement);
default T visitCorrelatedCrossJoin(SqmCorrelatedCrossJoin<?> join) {
return visitCrossJoin( join );
}
default T visitCorrelatedEntityJoin(SqmCorrelatedEntityJoin<?> join) {
return visitQualifiedEntityJoin( join );
}
default T visitCorrelatedPluralPartJoin(SqmCorrelatedPluralPartJoin<?, ?> join) {
return visitPluralPartJoin( join );
}
default T visitBagJoin(SqmBagJoin<?,?> join){
return visitQualifiedAttributeJoin( join );
}
default T visitCorrelatedBagJoin(SqmCorrelatedBagJoin<?, ?> join) {
return visitQualifiedAttributeJoin( join );
}
default T visitCorrelatedListJoin(SqmCorrelatedListJoin<?, ?> join) {
return visitQualifiedAttributeJoin( join );
}
default T visitCorrelatedMapJoin(SqmCorrelatedMapJoin<?, ?, ?> join) {
return visitQualifiedAttributeJoin( join );
}
default T visitCorrelatedSetJoin(SqmCorrelatedSetJoin<?, ?> join) {
return visitQualifiedAttributeJoin( join );
}
default T visitCorrelatedSingularJoin(SqmCorrelatedSingularJoin<?, ?> join) {
return visitQualifiedAttributeJoin( join );
}
default T visitListJoin(SqmListJoin<?, ?> join) {
return visitQualifiedAttributeJoin( join );
}
default T visitMapJoin(SqmMapJoin<?, ?, ?> join) {
return visitQualifiedAttributeJoin( join );
}
default T visitSetJoin(SqmSetJoin<?, ?> join) {
return visitQualifiedAttributeJoin( join );
}
default T visitSingularJoin(SqmSingularJoin<?, ?> join) {
return visitQualifiedAttributeJoin( join );
}
T visitQualifiedDerivedJoin(SqmDerivedJoin<?> joinedFromElement);
T visitQualifiedCteJoin(SqmCteJoin<?> joinedFromElement);
@ -177,6 +244,13 @@ public interface SemanticQueryWalker<T> {
T visitCorrelation(SqmCorrelation<?, ?> correlation);
default T visitCorrelatedRootJoin(SqmCorrelatedRootJoin<?> correlatedRootJoin){
return visitCorrelation( correlatedRootJoin );
}
default T visitCorrelatedRoot(SqmCorrelatedRoot<?> correlatedRoot){
return visitCorrelation( correlatedRoot );
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Query spec
@ -328,4 +402,5 @@ public interface SemanticQueryWalker<T> {
T visitMapEntryFunction(SqmMapEntryReference<?, ?> function);
T visitFullyQualifiedClass(Class<?> namedClass);
}

View File

@ -10,6 +10,7 @@ import java.util.Collection;
import org.hibernate.metamodel.model.domain.BagPersistentAttribute;
import org.hibernate.metamodel.model.domain.EntityDomainType;
import org.hibernate.query.sqm.SemanticQueryWalker;
import org.hibernate.spi.NavigablePath;
import org.hibernate.query.criteria.JpaCollectionJoin;
import org.hibernate.query.criteria.JpaExpression;
@ -81,6 +82,11 @@ public class SqmBagJoin<O, E> extends AbstractSqmPluralJoin<O,Collection<E>, E>
return getReferencedPathSource();
}
@Override
public <X> X accept(SemanticQueryWalker<X> walker) {
return walker.visitBagJoin( this );
}
@Override
public BagPersistentAttribute<O,E> getAttribute() {
//noinspection unchecked
@ -149,4 +155,5 @@ public class SqmBagJoin<O, E> extends AbstractSqmPluralJoin<O,Collection<E>, E>
nodeBuilder()
);
}
}

View File

@ -10,6 +10,7 @@ import org.hibernate.metamodel.model.domain.BagPersistentAttribute;
import org.hibernate.query.hql.spi.SqmCreationProcessingState;
import org.hibernate.query.hql.spi.SqmPathRegistry;
import org.hibernate.query.sqm.NodeBuilder;
import org.hibernate.query.sqm.SemanticQueryWalker;
import org.hibernate.query.sqm.tree.SqmCopyContext;
import org.hibernate.query.sqm.tree.SqmJoinType;
import org.hibernate.query.sqm.tree.from.SqmFrom;
@ -74,6 +75,11 @@ public class SqmCorrelatedBagJoin<O, T> extends SqmBagJoin<O, T> implements SqmC
return path;
}
@Override
public <X> X accept(SemanticQueryWalker<X> walker) {
return walker.visitCorrelatedBagJoin( this );
}
@Override
public SqmBagJoin<O, T> getCorrelationParent() {
return correlationParent;
@ -108,4 +114,5 @@ public class SqmCorrelatedBagJoin<O, T> extends SqmBagJoin<O, T> implements SqmC
pathRegistry.findFromByPath( correlationParent.getNavigablePath() )
);
}
}

View File

@ -9,6 +9,7 @@ package org.hibernate.query.sqm.tree.domain;
import org.hibernate.metamodel.model.domain.EntityDomainType;
import org.hibernate.query.hql.spi.SqmCreationProcessingState;
import org.hibernate.query.hql.spi.SqmPathRegistry;
import org.hibernate.query.sqm.SemanticQueryWalker;
import org.hibernate.query.sqm.tree.SqmCopyContext;
import org.hibernate.query.sqm.tree.from.SqmCrossJoin;
import org.hibernate.query.sqm.tree.from.SqmRoot;
@ -94,4 +95,10 @@ public class SqmCorrelatedCrossJoin<T> extends SqmCrossJoin<T> implements SqmCor
pathRegistry.findFromByPath( correlationParent.getNavigablePath() )
);
}
@Override
public <X> X accept(SemanticQueryWalker<X> walker) {
return walker.visitCorrelatedCrossJoin( this );
}
}

View File

@ -9,6 +9,7 @@ package org.hibernate.query.sqm.tree.domain;
import org.hibernate.metamodel.model.domain.EntityDomainType;
import org.hibernate.query.hql.spi.SqmCreationProcessingState;
import org.hibernate.query.hql.spi.SqmPathRegistry;
import org.hibernate.query.sqm.SemanticQueryWalker;
import org.hibernate.query.sqm.tree.SqmCopyContext;
import org.hibernate.query.sqm.tree.SqmJoinType;
import org.hibernate.query.sqm.tree.from.SqmEntityJoin;
@ -67,6 +68,11 @@ public class SqmCorrelatedEntityJoin<T> extends SqmEntityJoin<T> implements SqmC
return path;
}
@Override
public <X> X accept(SemanticQueryWalker<X> walker) {
return walker.visitCorrelatedEntityJoin(this);
}
@Override
public SqmEntityJoin<T> getCorrelationParent() {
return correlationParent;
@ -99,4 +105,5 @@ public class SqmCorrelatedEntityJoin<T> extends SqmEntityJoin<T> implements SqmC
pathRegistry.findFromByPath( correlationParent.getNavigablePath() )
);
}
}

View File

@ -10,6 +10,7 @@ import org.hibernate.metamodel.model.domain.ListPersistentAttribute;
import org.hibernate.query.hql.spi.SqmCreationProcessingState;
import org.hibernate.query.hql.spi.SqmPathRegistry;
import org.hibernate.query.sqm.NodeBuilder;
import org.hibernate.query.sqm.SemanticQueryWalker;
import org.hibernate.query.sqm.tree.SqmCopyContext;
import org.hibernate.query.sqm.tree.SqmJoinType;
import org.hibernate.query.sqm.tree.from.SqmFrom;
@ -108,4 +109,9 @@ public class SqmCorrelatedListJoin<O, T> extends SqmListJoin<O, T> implements Sq
pathRegistry.findFromByPath( correlationParent.getNavigablePath() )
);
}
@Override
public <X> X accept(SemanticQueryWalker<X> walker) {
return walker.visitCorrelatedListJoin( this );
}
}

View File

@ -10,6 +10,7 @@ import org.hibernate.metamodel.model.domain.MapPersistentAttribute;
import org.hibernate.query.hql.spi.SqmCreationProcessingState;
import org.hibernate.query.hql.spi.SqmPathRegistry;
import org.hibernate.query.sqm.NodeBuilder;
import org.hibernate.query.sqm.SemanticQueryWalker;
import org.hibernate.query.sqm.tree.SqmCopyContext;
import org.hibernate.query.sqm.tree.SqmJoinType;
import org.hibernate.query.sqm.tree.from.SqmFrom;
@ -108,4 +109,9 @@ public class SqmCorrelatedMapJoin<O, K, V> extends SqmMapJoin<O, K, V> implement
pathRegistry.findFromByPath( correlationParent.getNavigablePath() )
);
}
@Override
public <X> X accept(SemanticQueryWalker<X> walker) {
return walker.visitCorrelatedMapJoin( this );
}
}

View File

@ -6,6 +6,7 @@
*/
package org.hibernate.query.sqm.tree.domain;
import org.hibernate.query.sqm.SemanticQueryWalker;
import org.hibernate.query.sqm.tree.SqmCopyContext;
import org.hibernate.query.sqm.tree.SqmJoinType;
import org.hibernate.query.sqm.tree.from.SqmFrom;
@ -46,6 +47,16 @@ public class SqmCorrelatedPluralPartJoin<O, T> extends SqmPluralPartJoin<O, T> i
return path;
}
@Override
public <X> X accept(SemanticQueryWalker<X> walker) {
return walker.visitCorrelatedPluralPartJoin( this );
}
@Override
public SqmFrom<?, T> getLhs() {
return (SqmFrom<?, T>) super.getLhs();
}
@Override
public SqmPluralPartJoin<O, T> getCorrelationParent() {
return correlationParent;
@ -65,4 +76,5 @@ public class SqmCorrelatedPluralPartJoin<O, T> extends SqmPluralPartJoin<O, T> i
public SqmRoot<O> getCorrelatedRoot() {
return correlatedRootJoin;
}
}

View File

@ -14,7 +14,7 @@ import org.hibernate.query.sqm.tree.from.SqmRoot;
/**
* @author Steve Ebersole
*/
public class SqmCorrelatedRoot<T> extends SqmRoot<T> implements SqmPathWrapper<T,T>, SqmCorrelation<T,T> {
public class SqmCorrelatedRoot<T> extends SqmRoot<T> implements SqmPathWrapper<T, T>, SqmCorrelation<T, T> {
private final SqmRoot<T> correlationParent;
@ -80,6 +80,6 @@ public class SqmCorrelatedRoot<T> extends SqmRoot<T> implements SqmPathWrapper<T
@Override
public <X> X accept(SemanticQueryWalker<X> walker) {
return walker.visitCorrelation( this );
return walker.visitCorrelatedRoot( this );
}
}

View File

@ -20,7 +20,7 @@ import org.hibernate.query.sqm.tree.from.SqmRoot;
*/
public class SqmCorrelatedRootJoin<T> extends SqmRoot<T> implements SqmCorrelation<T, T> {
SqmCorrelatedRootJoin(
public SqmCorrelatedRootJoin(
NavigablePath navigablePath,
SqmPathSource<T> referencedNavigable,
NodeBuilder nodeBuilder) {
@ -89,6 +89,7 @@ public class SqmCorrelatedRootJoin<T> extends SqmRoot<T> implements SqmCorrelati
@Override
public <X> X accept(SemanticQueryWalker<X> walker) {
return walker.visitCorrelation( this );
return walker.visitCorrelatedRootJoin( this );
}
}

View File

@ -10,6 +10,7 @@ import org.hibernate.metamodel.model.domain.SetPersistentAttribute;
import org.hibernate.query.hql.spi.SqmCreationProcessingState;
import org.hibernate.query.hql.spi.SqmPathRegistry;
import org.hibernate.query.sqm.NodeBuilder;
import org.hibernate.query.sqm.SemanticQueryWalker;
import org.hibernate.query.sqm.tree.SqmCopyContext;
import org.hibernate.query.sqm.tree.SqmJoinType;
import org.hibernate.query.sqm.tree.from.SqmFrom;
@ -108,4 +109,9 @@ public class SqmCorrelatedSetJoin<O, T> extends SqmSetJoin<O, T> implements SqmC
pathRegistry.findFromByPath( correlationParent.getNavigablePath() )
);
}
@Override
public <X> X accept(SemanticQueryWalker<X> walker) {
return walker.visitCorrelatedSetJoin( this );
}
}

View File

@ -10,6 +10,7 @@ import org.hibernate.metamodel.model.domain.SingularPersistentAttribute;
import org.hibernate.query.hql.spi.SqmCreationProcessingState;
import org.hibernate.query.hql.spi.SqmPathRegistry;
import org.hibernate.query.sqm.NodeBuilder;
import org.hibernate.query.sqm.SemanticQueryWalker;
import org.hibernate.query.sqm.tree.SqmCopyContext;
import org.hibernate.query.sqm.tree.SqmJoinType;
import org.hibernate.query.sqm.tree.from.SqmFrom;
@ -108,4 +109,9 @@ public class SqmCorrelatedSingularJoin<O, T> extends SqmSingularJoin<O, T> imple
pathRegistry.findFromByPath( correlationParent.getNavigablePath() )
);
}
@Override
public <X> X accept(SemanticQueryWalker<X> walker) {
return walker.visitCorrelatedSingularJoin( this );
}
}

View File

@ -17,4 +17,5 @@ import org.hibernate.query.sqm.tree.from.SqmRoot;
*/
public interface SqmCorrelation<O, T> extends SqmFrom<O, T>, SqmPathWrapper<T, T> {
SqmRoot<O> getCorrelatedRoot();
}

View File

@ -10,6 +10,7 @@ import java.util.List;
import org.hibernate.metamodel.model.domain.EntityDomainType;
import org.hibernate.metamodel.model.domain.ListPersistentAttribute;
import org.hibernate.query.sqm.SemanticQueryWalker;
import org.hibernate.spi.NavigablePath;
import org.hibernate.query.criteria.JpaExpression;
import org.hibernate.query.criteria.JpaListJoin;
@ -84,6 +85,11 @@ public class SqmListJoin<O,E>
return getReferencedPathSource();
}
@Override
public <X> X accept(SemanticQueryWalker<X> walker) {
return walker.visitListJoin( this );
}
@Override
public ListPersistentAttribute<O,E> getAttribute() {
//noinspection unchecked
@ -156,4 +162,5 @@ public class SqmListJoin<O,E>
nodeBuilder()
);
}
}

View File

@ -13,6 +13,7 @@ import jakarta.persistence.criteria.Predicate;
import org.hibernate.metamodel.model.domain.EntityDomainType;
import org.hibernate.metamodel.model.domain.MapPersistentAttribute;
import org.hibernate.query.sqm.SemanticQueryWalker;
import org.hibernate.spi.NavigablePath;
import org.hibernate.query.criteria.JpaExpression;
import org.hibernate.query.criteria.JpaMapJoin;
@ -83,6 +84,11 @@ public class SqmMapJoin<O, K, V>
return (MapPersistentAttribute<O, K, V>) super.getModel();
}
@Override
public <X> X accept(SemanticQueryWalker<X> walker) {
return walker.visitMapJoin( this );
}
@Override
public MapPersistentAttribute<O, K, V> getAttribute() {
//noinspection unchecked
@ -170,4 +176,5 @@ public class SqmMapJoin<O, K, V>
nodeBuilder()
);
}
}

View File

@ -10,6 +10,7 @@ import java.util.Set;
import org.hibernate.metamodel.model.domain.EntityDomainType;
import org.hibernate.metamodel.model.domain.SetPersistentAttribute;
import org.hibernate.query.sqm.SemanticQueryWalker;
import org.hibernate.spi.NavigablePath;
import org.hibernate.query.criteria.JpaExpression;
import org.hibernate.query.criteria.JpaPredicate;
@ -83,6 +84,11 @@ public class SqmSetJoin<O, E>
return getReferencedPathSource();
}
@Override
public <X> X accept(SemanticQueryWalker<X> walker) {
return walker.visitSetJoin( this );
}
@Override
public SetPersistentAttribute<O,E> getAttribute() {
return getReferencedPathSource();
@ -142,6 +148,7 @@ public class SqmSetJoin<O, E>
return fetch( attributeName, JoinType.INNER);
}
@Override
public SqmAttributeJoin<O, E> makeCopy(SqmCreationProcessingState creationProcessingState) {
return new SqmSetJoin<>(

View File

@ -10,6 +10,7 @@ import java.util.Locale;
import org.hibernate.metamodel.model.domain.EntityDomainType;
import org.hibernate.metamodel.model.domain.SingularPersistentAttribute;
import org.hibernate.query.sqm.SemanticQueryWalker;
import org.hibernate.spi.NavigablePath;
import org.hibernate.query.hql.spi.SqmCreationProcessingState;
import org.hibernate.query.sqm.NodeBuilder;
@ -43,6 +44,11 @@ public class SqmSingularJoin<O,T> extends AbstractSqmAttributeJoin<O,T> {
super( lhs, joinedNavigable, alias, joinType, fetched, nodeBuilder );
}
@Override
public <X> X accept(SemanticQueryWalker<X> walker) {
return walker.visitSingularJoin(this);
}
protected SqmSingularJoin(
SqmFrom<?, O> lhs,
NavigablePath navigablePath,

View File

@ -6,13 +6,12 @@
*/
package org.hibernate.query.sqm.tree.from;
import org.hibernate.HibernateException;
import org.hibernate.Remove;
import org.hibernate.metamodel.model.domain.EntityDomainType;
import org.hibernate.query.criteria.JpaFetch;
import org.hibernate.query.criteria.JpaJoin;
import org.hibernate.query.sqm.SqmPathSource;
import org.hibernate.query.hql.spi.SqmCreationProcessingState;
import org.hibernate.query.sqm.tree.domain.SqmPath;
import org.hibernate.query.sqm.SqmPathSource;
import org.hibernate.query.sqm.tree.predicate.SqmPredicate;
import org.hibernate.type.descriptor.java.JavaType;
@ -44,15 +43,11 @@ public interface SqmAttributeJoin<O,T> extends SqmQualifiedJoin<O,T>, JpaFetch<O
@Override
<S extends T> SqmAttributeJoin<O, S> treatAs(EntityDomainType<S> treatTarget);
SqmAttributeJoin makeCopy(SqmCreationProcessingState creationProcessingState);
/*
@deprecated not used anymore
*/
@Deprecated
@Remove
SqmAttributeJoin makeCopy( SqmCreationProcessingState creationProcessingState );
class NotJoinableException extends HibernateException {
public NotJoinableException(String message) {
super( message );
}
public NotJoinableException(String message, Throwable cause) {
super( message, cause );
}
}
}