add some accessor methods onto AbstractCommonQueryContract

gavinking · gavinking · commit f4eaa7fc204f · 2025-05-14T08:08:58.000+02:00
diff --git a/hibernate-core/src/main/java/org/hibernate/procedure/internal/ProcedureCallImpl.java b/hibernate-core/src/main/java/org/hibernate/procedure/internal/ProcedureCallImpl.java
@@ -76,7 +76,6 @@
 import org.hibernate.sql.exec.spi.JdbcParameterBindings;
 import org.hibernate.sql.results.NoMoreOutputsException;
 import org.hibernate.type.BasicType;
-import org.hibernate.type.spi.TypeConfiguration;
 
 import jakarta.persistence.CacheRetrieveMode;
 import jakarta.persistence.CacheStoreMode;
@@ -172,7 +171,7 @@ public ProcedureCallImpl(SharedSessionContractImplementor session, String proced
 				resultClasses,
 				resultSetMapping,
 				synchronizedQuerySpaces::add,
-				() -> getSession().getFactory()
+				this::getSessionFactory
 		);
 	}
 
@@ -205,7 +204,7 @@ public ProcedureCallImpl(
 				resultSetMappingNames,
 				resultSetMapping,
 				synchronizedQuerySpaces::add,
-				() -> getSession().getFactory()
+				this::getSessionFactory
 		);
 	}
 
@@ -232,7 +231,7 @@ public ProcedureCallImpl(
 				memento.getResultSetMappingClasses(),
 				resultSetMapping,
 				synchronizedQuerySpaces::add,
-				() -> getSession().getFactory()
+				this::getSessionFactory
 		);
 
 		applyOptions( memento );
@@ -265,7 +264,7 @@ public ProcedureCallImpl(
 				resultTypes,
 				resultSetMapping,
 				synchronizedQuerySpaces::add,
-				getSession()::getFactory
+				this::getSessionFactory
 		);
 
 		applyOptions( memento );
@@ -292,7 +291,7 @@ public ProcedureCallImpl(
 				null,
 				resultSetMapping,
 				synchronizedQuerySpaces::add,
-				() -> getSession().getFactory()
+				this::getSessionFactory
 		);
 
 		applyOptions( memento );
@@ -362,10 +361,6 @@ private void markAsFunctionCallRefRefCursor() {
 		functionReturn = new FunctionReturnImpl<>( this, Types.REF_CURSOR );
 	}
 
-	private TypeConfiguration getTypeConfiguration() {
-		return getSessionFactory().getTypeConfiguration();
-	}
-
 	@Override
 	public ProcedureCallImpl<R> markAsFunctionCall(Class<?> resultType) {
 		final BasicType<?> basicType = getTypeConfiguration().getBasicTypeForJavaType( resultType );
@@ -418,7 +413,7 @@ public ProcedureCallImplementor<R> registerStoredProcedureParameter(int position
 			registerParameter( position, type, mode );
 		}
 		catch (HibernateException he) {
-			throw getSession().getExceptionConverter().convert( he );
+			throw getExceptionConverter().convert( he );
 		}
 		catch (RuntimeException e) {
 			getSession().markForRollbackOnly();
@@ -437,7 +432,7 @@ public ProcedureCallImplementor<R> registerStoredProcedureParameter(
 			registerParameter( parameterName, type, mode );
 		}
 		catch (HibernateException he) {
-			throw getSession().getExceptionConverter().convert( he );
+			throw getExceptionConverter().convert( he );
 		}
 		catch (RuntimeException e) {
 			getSession().markForRollbackOnly();
@@ -457,7 +452,7 @@ public ProcedureCallImplementor<R> registerStoredProcedureParameter(
 			registerParameter( position, type, mode );
 		}
 		catch (HibernateException he) {
-			throw getSession().getExceptionConverter().convert( he );
+			throw getExceptionConverter().convert( he );
 		}
 		catch (RuntimeException e) {
 			getSession().markForRollbackOnly();
@@ -476,7 +471,7 @@ public ProcedureCallImplementor<R> registerStoredProcedureParameter(
 			registerParameter( parameterName, type, mode );
 		}
 		catch (HibernateException he) {
-			throw getSession().getExceptionConverter().convert( he );
+			throw getExceptionConverter().convert( he );
 		}
 		catch (RuntimeException e) {
 			getSession().markForRollbackOnly();
@@ -726,7 +721,7 @@ public ProcedureCallImplementor<R> addSynchronizedQuerySpace(String querySpace)
 	@Override
 	public ProcedureCallImplementor<R> addSynchronizedEntityName(String entityName) {
 		final EntityPersister entityDescriptor =
-				getSession().getFactory().getMappingMetamodel()
+				this.getSessionFactory().getMappingMetamodel()
 						.getEntityDescriptor( entityName );
 		addSynchronizedQuerySpaces( entityDescriptor );
 		return this;
@@ -739,7 +734,7 @@ protected void addSynchronizedQuerySpaces(EntityPersister persister) {
 	@Override
 	public ProcedureCallImplementor<R> addSynchronizedEntityClass(@SuppressWarnings("rawtypes") Class entityClass) {
 		final EntityPersister entityDescriptor =
-				getSession().getFactory().getMappingMetamodel()
+				this.getSessionFactory().getMappingMetamodel()
 						.getEntityDescriptor( entityClass );
 		addSynchronizedQuerySpaces( entityDescriptor );
 		return this;
@@ -810,7 +805,7 @@ public boolean execute() {
 			return false;
 		}
 		catch (HibernateException he) {
-			throw getSession().getExceptionConverter().convert( he );
+			throw getExceptionConverter().convert( he );
 		}
 		catch (RuntimeException e) {
 			getSession().markForRollbackOnly();
@@ -892,7 +887,7 @@ else if ( rtn instanceof UpdateCountOutput updateCount ) {
 			return -1;
 		}
 		catch (HibernateException he) {
-			throw getSession().getExceptionConverter().convert( he );
+			throw getExceptionConverter().convert( he );
 		}
 		catch (RuntimeException e) {
 			getSession().markForRollbackOnly();
@@ -922,7 +917,7 @@ protected List<R> doList() {
 				return null;
 			}
 			catch (HibernateException he) {
-				throw getSession().getExceptionConverter().convert( he );
+				throw getExceptionConverter().convert( he );
 			}
 			catch (RuntimeException e) {
 				getSession().markForRollbackOnly();
diff --git a/hibernate-core/src/main/java/org/hibernate/query/spi/AbstractCommonQueryContract.java b/hibernate-core/src/main/java/org/hibernate/query/spi/AbstractCommonQueryContract.java
@@ -14,6 +14,8 @@
 
 import org.hibernate.FlushMode;
 import org.hibernate.Internal;
+import org.hibernate.engine.spi.ExceptionConverter;
+import org.hibernate.engine.spi.SessionFactoryImplementor;
 import org.hibernate.query.QueryArgumentException;
 import org.hibernate.query.QueryFlushMode;
 import org.hibernate.HibernateException;
@@ -28,8 +30,6 @@
 import org.hibernate.graph.spi.RootGraphImplementor;
 import org.hibernate.jpa.internal.util.ConfigurationHelper;
 import org.hibernate.jpa.internal.util.FlushModeTypeHelper;
-import org.hibernate.metamodel.RuntimeMetamodels;
-import org.hibernate.metamodel.model.domain.JpaMetamodel;
 import org.hibernate.metamodel.model.domain.ManagedDomainType;
 import org.hibernate.property.access.spi.BuiltInPropertyAccessStrategies;
 import org.hibernate.property.access.spi.Getter;
@@ -112,10 +112,22 @@ protected AbstractCommonQueryContract(AbstractCommonQueryContract original) {
 		this.queryOptions = original.queryOptions;
 	}
 
-	public SharedSessionContractImplementor getSession() {
+	public final SharedSessionContractImplementor getSession() {
 		return session;
 	}
 
+	public final SessionFactoryImplementor getSessionFactory() {
+		return session.getFactory();
+	}
+
+	public final TypeConfiguration getTypeConfiguration() {
+		return session.getFactory().getTypeConfiguration();
+	}
+
+	protected final ExceptionConverter getExceptionConverter() {
+		return session.getExceptionConverter();
+	}
+
 	protected int getIntegerLiteral(JpaExpression<Number> expression, int defaultValue) {
 		if ( expression == null ) {
 			return defaultValue;
@@ -379,14 +391,16 @@ protected void applyGraph(String graphString, GraphSemantic graphSemantic) {
 			);
 		}
 
-		final RuntimeMetamodels runtimeMetamodels = getSession().getFactory().getRuntimeMetamodels();
-		final JpaMetamodel jpaMetamodel = runtimeMetamodels.getJpaMetamodel();
+		final var factory = getSessionFactory();
 
-		final String entityName = runtimeMetamodels.getImportedName( graphString.substring( 0, separatorPosition ).trim() );
+		final String entityName =
+				factory.getMappingMetamodel()
+						.getImportedName( graphString.substring( 0, separatorPosition ).trim() );
 		final String graphNodes = graphString.substring( separatorPosition + 1, terminatorPosition );
 
-		final RootGraphImpl<?> rootGraph = new RootGraphImpl<>( null, jpaMetamodel.entity( entityName ) );
-		GraphParser.parseInto( (EntityGraph<?>) rootGraph, graphNodes, getSession().getSessionFactory() );
+		final RootGraphImpl<?> rootGraph =
+				new RootGraphImpl<>( null, factory.getJpaMetamodel().entity( entityName ) );
+		GraphParser.parseInto( (EntityGraph<?>) rootGraph, graphNodes, getSessionFactory() );
 		applyGraph( rootGraph, graphSemantic );
 	}
 
@@ -587,7 +601,7 @@ public QueryParameterImplementor<?> getParameter(String name) {
 			return getParameterMetadata().getQueryParameter( name );
 		}
 		catch ( HibernateException e ) {
-			throw getSession().getExceptionConverter().convert( e );
+			throw getExceptionConverter().convert( e );
 		}
 	}
 
@@ -608,7 +622,7 @@ public <T> QueryParameterImplementor<T> getParameter(String name, Class<T> type)
 			return parameter;
 		}
 		catch ( HibernateException e ) {
-			throw getSession().getExceptionConverter().convert( e );
+			throw getExceptionConverter().convert( e );
 		}
 	}
 
@@ -619,7 +633,7 @@ public QueryParameterImplementor<?> getParameter(int position) {
 			return getParameterMetadata().getQueryParameter( position );
 		}
 		catch ( HibernateException e ) {
-			throw getSession().getExceptionConverter().convert( e );
+			throw getExceptionConverter().convert( e );
 		}
 	}
 
@@ -639,7 +653,7 @@ public <T> QueryParameterImplementor<T> getParameter(int position, Class<T> type
 			return parameter;
 		}
 		catch ( HibernateException e ) {
-			throw getSession().getExceptionConverter().convert( e );
+			throw getExceptionConverter().convert( e );
 		}
 	}
 
@@ -652,7 +666,7 @@ public <T> QueryParameterImplementor<T> getParameter(int position, Class<T> type
 	protected abstract boolean resolveJdbcParameterTypeIfNecessary();
 
 	private <P> JavaType<P> getJavaType(Class<P> javaType) {
-		return getSession().getFactory().getTypeConfiguration().getJavaTypeRegistry()
+		return getTypeConfiguration().getJavaTypeRegistry()
 				.getDescriptor( javaType );
 	}
 
@@ -667,7 +681,7 @@ else if ( parameter.getPosition() != null ) {
 			return locateBinding( parameter.getPosition() );
 		}
 
-		throw getSession().getExceptionConverter().convert(
+		throw getExceptionConverter().convert(
 				new IllegalArgumentException( "Could not resolve binding for given parameter reference [" + parameter + "]" )
 		);
 	}
@@ -788,7 +802,7 @@ private boolean isInstance(Type<?> parameterType, Object value) {
 	}
 
 	private NodeBuilder getNodeuilder() {
-		return getSession().getFactory().getQueryEngine().getCriteriaBuilder();
+		return getSessionFactory().getQueryEngine().getCriteriaBuilder();
 	}
 
 	@Override
@@ -835,7 +849,7 @@ public CommonQueryContract setParameter(int position, Object value) {
 	}
 
 	private boolean isRegisteredAsBasicType(Class<?> valueClass) {
-		return getSession().getFactory().getTypeConfiguration().getBasicTypeForJavaType( valueClass ) != null;
+		return getTypeConfiguration().getBasicTypeForJavaType( valueClass ) != null;
 	}
 
 	@Override
@@ -1028,14 +1042,16 @@ public <P> CommonQueryContract setParameterList(int position, Collection<? exten
 	}
 
 	private <P> Type<P> getParamType(Class<P> javaType) {
-		final TypeConfiguration typeConfiguration = getSession().getFactory().getTypeConfiguration();
-		final BasicType<P> basicType = typeConfiguration.standardBasicTypeForJavaType( javaType );
+		final BasicType<P> basicType =
+				getTypeConfiguration()
+						.standardBasicTypeForJavaType( javaType );
 		if ( basicType != null ) {
 			return basicType;
 		}
 		else {
-			final JpaMetamodel metamodel = getSession().getFactory().getJpaMetamodel();
-			final ManagedDomainType<P> managedDomainType = metamodel.managedType( javaType );
+			final ManagedDomainType<P> managedDomainType =
+					getSessionFactory().getJpaMetamodel()
+							.managedType( javaType );
 			if ( managedDomainType != null ) {
 				return managedDomainType;
 			}
@@ -1157,7 +1173,7 @@ protected <T> Type<T> determineType(String namedParam, Class<? extends T> retTyp
 			type = getParameterMetadata().getQueryParameter( namedParam ).getHibernateType();
 		}
 		if ( type == null && retType != null ) {
-			type = getSession().getFactory().getMappingMetamodel().resolveParameterBindType( retType );
+			type = getSessionFactory().getMappingMetamodel().resolveParameterBindType( retType );
 		}
 		if ( retType!= null && !retType.isAssignableFrom( type.getJavaType() ) ) {
 			throw new IllegalStateException( "Parameter not of expected type: " + retType.getName() );
diff --git a/hibernate-core/src/main/java/org/hibernate/query/spi/AbstractQuery.java b/hibernate-core/src/main/java/org/hibernate/query/spi/AbstractQuery.java
@@ -646,7 +646,7 @@ public int executeUpdate() throws HibernateException {
 			throw new IllegalStateException( e );
 		}
 		catch (HibernateException e) {
-			throw getSession().getExceptionConverter().convert( e );
+			throw getExceptionConverter().convert( e );
 		}
 		finally {
 			afterQueryHandlingFetchProfiles( success, fetchProfiles );
diff --git a/hibernate-core/src/main/java/org/hibernate/query/spi/AbstractSelectionQuery.java b/hibernate-core/src/main/java/org/hibernate/query/spi/AbstractSelectionQuery.java
@@ -29,7 +29,6 @@
 import org.hibernate.NonUniqueResultException;
 import org.hibernate.ScrollMode;
 import org.hibernate.UnknownProfileException;
-import org.hibernate.engine.spi.SessionFactoryImplementor;
 import org.hibernate.engine.spi.SharedSessionContractImplementor;
 import org.hibernate.graph.GraphSemantic;
 import org.hibernate.graph.spi.AppliedGraph;
@@ -150,7 +149,7 @@ public List<R> list() {
 			throw new IllegalStateException( e );
 		}
 		catch (HibernateException he) {
-			throw getSession().getExceptionConverter().convert( he, getQueryOptions().getLockOptions() );
+			throw getExceptionConverter().convert( he, getQueryOptions().getLockOptions() );
 		}
 		finally {
 			afterQueryHandlingFetchProfiles( success, fetchProfiles );
@@ -279,7 +278,7 @@ public R getSingleResult() {
 			return uniqueElement( list );
 		}
 		catch ( HibernateException e ) {
-			throw getSession().getExceptionConverter().convert( e, getQueryOptions().getLockOptions() );
+			throw getExceptionConverter().convert( e, getQueryOptions().getLockOptions() );
 		}
 	}
 
@@ -311,7 +310,7 @@ public R getSingleResultOrNull() {
 			return uniqueElement( list() );
 		}
 		catch ( HibernateException e ) {
-			throw getSession().getExceptionConverter().convert( e, getLockOptions() );
+			throw getExceptionConverter().convert( e, getLockOptions() );
 		}
 	}
 
@@ -383,7 +382,7 @@ public SelectionQuery<R> setEntityGraph(EntityGraph<? super R> graph, GraphSeman
 
 	@Override
 	public SelectionQuery<R> enableFetchProfile(String profileName) {
-		if ( getSession().getFactory().containsFetchProfileDefinition( profileName ) ) {
+		if ( this.getSessionFactory().containsFetchProfileDefinition( profileName ) ) {
 			getQueryOptions().enableFetchProfile( profileName );
 			return this;
 		}
@@ -837,8 +836,4 @@ public SelectionQuery<R> setProperties(Object bean) {
 		super.setProperties( bean );
 		return this;
 	}
-
-	public SessionFactoryImplementor getSessionFactory() {
-		return getSession().getFactory();
-	}
 }
diff --git a/hibernate-core/src/main/java/org/hibernate/query/sql/internal/NativeQueryImpl.java b/hibernate-core/src/main/java/org/hibernate/query/sql/internal/NativeQueryImpl.java
@@ -691,7 +691,7 @@ private boolean shouldFlush() {
 			final FlushMode flushMode = getQueryOptions().getFlushMode();
 			return switch ( flushMode == null ? getSession().getHibernateFlushMode() : flushMode ) {
 				// The JPA spec requires that we auto-flush before native queries
-				case AUTO -> getSession().getFactory().getSessionFactoryOptions().isJpaBootstrap();
+				case AUTO -> getSessionFactory().getSessionFactoryOptions().isJpaBootstrap();
 				case ALWAYS -> true;
 				default -> false;
 			};
diff --git a/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/QuerySqmImpl.java b/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/QuerySqmImpl.java
@@ -520,7 +520,7 @@ public int executeUpdate() {
 			throw new IllegalStateException( e );
 		}
 		catch (HibernateException e) {
-			throw getSession().getExceptionConverter().convert( e );
+			throw getExceptionConverter().convert( e );
 		}
 		finally {
 			afterQueryHandlingFetchProfiles( success, fetchProfiles );

Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,8 @@`
`14`	`14`
`15`	`15`	`import org.hibernate.FlushMode;`
`16`	`16`	`import org.hibernate.Internal;`
	`17`	`+import org.hibernate.engine.spi.ExceptionConverter;`
	`18`	`+import org.hibernate.engine.spi.SessionFactoryImplementor;`
`17`	`19`	`import org.hibernate.query.QueryArgumentException;`
`18`	`20`	`import org.hibernate.query.QueryFlushMode;`
`19`	`21`	`import org.hibernate.HibernateException;`
`@@ -28,8 +30,6 @@`
`28`	`30`	`import org.hibernate.graph.spi.RootGraphImplementor;`
`29`	`31`	`import org.hibernate.jpa.internal.util.ConfigurationHelper;`
`30`	`32`	`import org.hibernate.jpa.internal.util.FlushModeTypeHelper;`
`31`		`-import org.hibernate.metamodel.RuntimeMetamodels;`
`32`		`-import org.hibernate.metamodel.model.domain.JpaMetamodel;`
`33`	`33`	`import org.hibernate.metamodel.model.domain.ManagedDomainType;`
`34`	`34`	`import org.hibernate.property.access.spi.BuiltInPropertyAccessStrategies;`
`35`	`35`	`import org.hibernate.property.access.spi.Getter;`
`@@ -112,10 +112,22 @@ protected AbstractCommonQueryContract(AbstractCommonQueryContract original) {`
`112`	`112`	`this.queryOptions = original.queryOptions;`
`113`	`113`	`}`
`114`	`114`
`115`		`- public SharedSessionContractImplementor getSession() {`
	`115`	`+ public final SharedSessionContractImplementor getSession() {`
`116`	`116`	`return session;`
`117`	`117`	`}`
`118`	`118`
	`119`	`+ public final SessionFactoryImplementor getSessionFactory() {`
	`120`	`+ return session.getFactory();`
	`121`	`+ }`
	`122`	`+`
	`123`	`+ public final TypeConfiguration getTypeConfiguration() {`
	`124`	`+ return session.getFactory().getTypeConfiguration();`
	`125`	`+ }`
	`126`	`+`
	`127`	`+ protected final ExceptionConverter getExceptionConverter() {`
	`128`	`+ return session.getExceptionConverter();`
	`129`	`+ }`
	`130`	`+`
`119`	`131`	`protected int getIntegerLiteral(JpaExpression<Number> expression, int defaultValue) {`
`120`	`132`	`if ( expression == null ) {`
`121`	`133`	`return defaultValue;`
`@@ -379,14 +391,16 @@ protected void applyGraph(String graphString, GraphSemantic graphSemantic) {`
`379`	`391`	`);`
`380`	`392`	`}`
`381`	`393`
`382`		`- final RuntimeMetamodels runtimeMetamodels = getSession().getFactory().getRuntimeMetamodels();`
`383`		`- final JpaMetamodel jpaMetamodel = runtimeMetamodels.getJpaMetamodel();`
	`394`	`+ final var factory = getSessionFactory();`
`384`	`395`
`385`		`- final String entityName = runtimeMetamodels.getImportedName( graphString.substring( 0, separatorPosition ).trim() );`
	`396`	`+ final String entityName =`
	`397`	`+ factory.getMappingMetamodel()`
	`398`	`+ .getImportedName( graphString.substring( 0, separatorPosition ).trim() );`
`386`	`399`	`final String graphNodes = graphString.substring( separatorPosition + 1, terminatorPosition );`
`387`	`400`
`388`		`- final RootGraphImpl<?> rootGraph = new RootGraphImpl<>( null, jpaMetamodel.entity( entityName ) );`
`389`		`- GraphParser.parseInto( (EntityGraph<?>) rootGraph, graphNodes, getSession().getSessionFactory() );`
	`401`	`+ final RootGraphImpl<?> rootGraph =`
	`402`	`+ new RootGraphImpl<>( null, factory.getJpaMetamodel().entity( entityName ) );`
	`403`	`+ GraphParser.parseInto( (EntityGraph<?>) rootGraph, graphNodes, getSessionFactory() );`
`390`	`404`	`applyGraph( rootGraph, graphSemantic );`
`391`	`405`	`}`
`392`	`406`
`@@ -587,7 +601,7 @@ public QueryParameterImplementor<?> getParameter(String name) {`
`587`	`601`	`return getParameterMetadata().getQueryParameter( name );`
`588`	`602`	`}`
`589`	`603`	`catch ( HibernateException e ) {`
`590`		`- throw getSession().getExceptionConverter().convert( e );`
	`604`	`+ throw getExceptionConverter().convert( e );`
`591`	`605`	`}`
`592`	`606`	`}`
`593`	`607`
`@@ -608,7 +622,7 @@ public <T> QueryParameterImplementor<T> getParameter(String name, Class<T> type)`
`608`	`622`	`return parameter;`
`609`	`623`	`}`
`610`	`624`	`catch ( HibernateException e ) {`
`611`		`- throw getSession().getExceptionConverter().convert( e );`
	`625`	`+ throw getExceptionConverter().convert( e );`
`612`	`626`	`}`
`613`	`627`	`}`
`614`	`628`
`@@ -619,7 +633,7 @@ public QueryParameterImplementor<?> getParameter(int position) {`
`619`	`633`	`return getParameterMetadata().getQueryParameter( position );`
`620`	`634`	`}`
`621`	`635`	`catch ( HibernateException e ) {`
`622`		`- throw getSession().getExceptionConverter().convert( e );`
	`636`	`+ throw getExceptionConverter().convert( e );`
`623`	`637`	`}`
`624`	`638`	`}`
`625`	`639`
`@@ -639,7 +653,7 @@ public <T> QueryParameterImplementor<T> getParameter(int position, Class<T> type`
`639`	`653`	`return parameter;`
`640`	`654`	`}`
`641`	`655`	`catch ( HibernateException e ) {`
`642`		`- throw getSession().getExceptionConverter().convert( e );`
	`656`	`+ throw getExceptionConverter().convert( e );`
`643`	`657`	`}`
`644`	`658`	`}`
`645`	`659`
`@@ -652,7 +666,7 @@ public <T> QueryParameterImplementor<T> getParameter(int position, Class<T> type`
`652`	`666`	`protected abstract boolean resolveJdbcParameterTypeIfNecessary();`
`653`	`667`
`654`	`668`	`private <P> JavaType<P> getJavaType(Class<P> javaType) {`
`655`		`- return getSession().getFactory().getTypeConfiguration().getJavaTypeRegistry()`
	`669`	`+ return getTypeConfiguration().getJavaTypeRegistry()`
`656`	`670`	`.getDescriptor( javaType );`
`657`	`671`	`}`
`658`	`672`
`@@ -667,7 +681,7 @@ else if ( parameter.getPosition() != null ) {`
`667`	`681`	`return locateBinding( parameter.getPosition() );`
`668`	`682`	`}`
`669`	`683`
`670`		`- throw getSession().getExceptionConverter().convert(`
	`684`	`+ throw getExceptionConverter().convert(`
`671`	`685`	`new IllegalArgumentException( "Could not resolve binding for given parameter reference [" + parameter + "]" )`
`672`	`686`	`);`
`673`	`687`	`}`
`@@ -788,7 +802,7 @@ private boolean isInstance(Type<?> parameterType, Object value) {`
`788`	`802`	`}`
`789`	`803`
`790`	`804`	`private NodeBuilder getNodeuilder() {`
`791`		`- return getSession().getFactory().getQueryEngine().getCriteriaBuilder();`
	`805`	`+ return getSessionFactory().getQueryEngine().getCriteriaBuilder();`
`792`	`806`	`}`
`793`	`807`
`794`	`808`	`@Override`
`@@ -835,7 +849,7 @@ public CommonQueryContract setParameter(int position, Object value) {`
`835`	`849`	`}`
`836`	`850`
`837`	`851`	`private boolean isRegisteredAsBasicType(Class<?> valueClass) {`
`838`		`- return getSession().getFactory().getTypeConfiguration().getBasicTypeForJavaType( valueClass ) != null;`
	`852`	`+ return getTypeConfiguration().getBasicTypeForJavaType( valueClass ) != null;`
`839`	`853`	`}`
`840`	`854`
`841`	`855`	`@Override`
`@@ -1028,14 +1042,16 @@ public <P> CommonQueryContract setParameterList(int position, Collection<? exten`
`1028`	`1042`	`}`
`1029`	`1043`
`1030`	`1044`	`private <P> Type<P> getParamType(Class<P> javaType) {`
`1031`		`- final TypeConfiguration typeConfiguration = getSession().getFactory().getTypeConfiguration();`
`1032`		`- final BasicType<P> basicType = typeConfiguration.standardBasicTypeForJavaType( javaType );`
	`1045`	`+ final BasicType<P> basicType =`
	`1046`	`+ getTypeConfiguration()`
	`1047`	`+ .standardBasicTypeForJavaType( javaType );`
`1033`	`1048`	`if ( basicType != null ) {`
`1034`	`1049`	`return basicType;`
`1035`	`1050`	`}`
`1036`	`1051`	`else {`
`1037`		`- final JpaMetamodel metamodel = getSession().getFactory().getJpaMetamodel();`
`1038`		`- final ManagedDomainType<P> managedDomainType = metamodel.managedType( javaType );`
	`1052`	`+ final ManagedDomainType<P> managedDomainType =`
	`1053`	`+ getSessionFactory().getJpaMetamodel()`
	`1054`	`+ .managedType( javaType );`
`1039`	`1055`	`if ( managedDomainType != null ) {`
`1040`	`1056`	`return managedDomainType;`
`1041`	`1057`	`}`
`@@ -1157,7 +1173,7 @@ protected <T> Type<T> determineType(String namedParam, Class<? extends T> retTyp`
`1157`	`1173`	`type = getParameterMetadata().getQueryParameter( namedParam ).getHibernateType();`
`1158`	`1174`	`}`
`1159`	`1175`	`if ( type == null && retType != null ) {`
`1160`		`- type = getSession().getFactory().getMappingMetamodel().resolveParameterBindType( retType );`
	`1176`	`+ type = getSessionFactory().getMappingMetamodel().resolveParameterBindType( retType );`
`1161`	`1177`	`}`
`1162`	`1178`	`if ( retType!= null && !retType.isAssignableFrom( type.getJavaType() ) ) {`
`1163`	`1179`	`throw new IllegalStateException( "Parameter not of expected type: " + retType.getName() );`
Original file line number	Diff line number	Diff line change
`@@ -646,7 +646,7 @@ public int executeUpdate() throws HibernateException {`
`646`	`646`	`throw new IllegalStateException( e );`
`647`	`647`	`}`
`648`	`648`	`catch (HibernateException e) {`
`649`		`- throw getSession().getExceptionConverter().convert( e );`
	`649`	`+ throw getExceptionConverter().convert( e );`
`650`	`650`	`}`
`651`	`651`	`finally {`
`652`	`652`	`afterQueryHandlingFetchProfiles( success, fetchProfiles );`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,6 @@`
`29`	`29`	`import org.hibernate.NonUniqueResultException;`
`30`	`30`	`import org.hibernate.ScrollMode;`
`31`	`31`	`import org.hibernate.UnknownProfileException;`
`32`		`-import org.hibernate.engine.spi.SessionFactoryImplementor;`
`33`	`32`	`import org.hibernate.engine.spi.SharedSessionContractImplementor;`
`34`	`33`	`import org.hibernate.graph.GraphSemantic;`
`35`	`34`	`import org.hibernate.graph.spi.AppliedGraph;`
`@@ -150,7 +149,7 @@ public List<R> list() {`
`150`	`149`	`throw new IllegalStateException( e );`
`151`	`150`	`}`
`152`	`151`	`catch (HibernateException he) {`
`153`		`- throw getSession().getExceptionConverter().convert( he, getQueryOptions().getLockOptions() );`
	`152`	`+ throw getExceptionConverter().convert( he, getQueryOptions().getLockOptions() );`
`154`	`153`	`}`
`155`	`154`	`finally {`
`156`	`155`	`afterQueryHandlingFetchProfiles( success, fetchProfiles );`
`@@ -279,7 +278,7 @@ public R getSingleResult() {`
`279`	`278`	`return uniqueElement( list );`
`280`	`279`	`}`
`281`	`280`	`catch ( HibernateException e ) {`
`282`		`- throw getSession().getExceptionConverter().convert( e, getQueryOptions().getLockOptions() );`
	`281`	`+ throw getExceptionConverter().convert( e, getQueryOptions().getLockOptions() );`
`283`	`282`	`}`
`284`	`283`	`}`
`285`	`284`
`@@ -311,7 +310,7 @@ public R getSingleResultOrNull() {`
`311`	`310`	`return uniqueElement( list() );`
`312`	`311`	`}`
`313`	`312`	`catch ( HibernateException e ) {`
`314`		`- throw getSession().getExceptionConverter().convert( e, getLockOptions() );`
	`313`	`+ throw getExceptionConverter().convert( e, getLockOptions() );`
`315`	`314`	`}`
`316`	`315`	`}`
`317`	`316`
`@@ -383,7 +382,7 @@ public SelectionQuery<R> setEntityGraph(EntityGraph<? super R> graph, GraphSeman`
`383`	`382`
`384`	`383`	`@Override`
`385`	`384`	`public SelectionQuery<R> enableFetchProfile(String profileName) {`
`386`		`- if ( getSession().getFactory().containsFetchProfileDefinition( profileName ) ) {`
	`385`	`+ if ( this.getSessionFactory().containsFetchProfileDefinition( profileName ) ) {`
`387`	`386`	`getQueryOptions().enableFetchProfile( profileName );`
`388`	`387`	`return this;`
`389`	`388`	`}`
`@@ -837,8 +836,4 @@ public SelectionQuery<R> setProperties(Object bean) {`
`837`	`836`	`super.setProperties( bean );`
`838`	`837`	`return this;`
`839`	`838`	`}`
`840`		`-`
`841`		`- public SessionFactoryImplementor getSessionFactory() {`
`842`		`- return getSession().getFactory();`
`843`		`- }`
`844`	`839`	`}`
Original file line number	Diff line number	Diff line change
`@@ -520,7 +520,7 @@ public int executeUpdate() {`
`520`	`520`	`throw new IllegalStateException( e );`
`521`	`521`	`}`
`522`	`522`	`catch (HibernateException e) {`
`523`		`- throw getSession().getExceptionConverter().convert( e );`
	`523`	`+ throw getExceptionConverter().convert( e );`
`524`	`524`	`}`
`525`	`525`	`finally {`
`526`	`526`	`afterQueryHandlingFetchProfiles( success, fetchProfiles );`