From 9dbfc297492ecb366ee1cf0c8e01f36ec890a492 Mon Sep 17 00:00:00 2001 From: Gavin Date: Fri, 23 Dec 2022 20:27:16 +0100 Subject: [PATCH] introduce SharedSessionDelegatorBaseImpl --- .../spi/SharedSessionDelegatorBaseImpl.java | 586 ++++++++++++++++++ 1 file changed, 586 insertions(+) create mode 100644 hibernate-core/src/main/java/org/hibernate/engine/spi/SharedSessionDelegatorBaseImpl.java diff --git a/hibernate-core/src/main/java/org/hibernate/engine/spi/SharedSessionDelegatorBaseImpl.java b/hibernate-core/src/main/java/org/hibernate/engine/spi/SharedSessionDelegatorBaseImpl.java new file mode 100644 index 0000000000..ca1f6dc656 --- /dev/null +++ b/hibernate-core/src/main/java/org/hibernate/engine/spi/SharedSessionDelegatorBaseImpl.java @@ -0,0 +1,586 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * License: GNU Lesser General Public License (LGPL), version 2.1 or later. + * See the lgpl.txt file in the root directory or . + */ +package org.hibernate.engine.spi; + +import jakarta.persistence.FlushModeType; +import jakarta.persistence.criteria.CriteriaDelete; +import jakarta.persistence.criteria.CriteriaQuery; +import jakarta.persistence.criteria.CriteriaUpdate; +import org.hibernate.CacheMode; +import org.hibernate.FlushMode; +import org.hibernate.HibernateException; +import org.hibernate.Interceptor; +import org.hibernate.SharedSessionContract; +import org.hibernate.Transaction; +import org.hibernate.cache.spi.CacheTransactionSynchronization; +import org.hibernate.collection.spi.PersistentCollection; +import org.hibernate.engine.jdbc.LobCreator; +import org.hibernate.engine.jdbc.connections.spi.JdbcConnectionAccess; +import org.hibernate.engine.jdbc.spi.JdbcCoordinator; +import org.hibernate.engine.jdbc.spi.JdbcServices; +import org.hibernate.jdbc.ReturningWork; +import org.hibernate.jdbc.Work; +import org.hibernate.persister.entity.EntityPersister; +import org.hibernate.procedure.ProcedureCall; +import org.hibernate.query.MutationQuery; +import org.hibernate.query.SelectionQuery; +import org.hibernate.query.criteria.HibernateCriteriaBuilder; +import org.hibernate.query.criteria.JpaCriteriaInsertSelect; +import org.hibernate.query.spi.QueryImplementor; +import org.hibernate.query.spi.QueryProducerImplementor; +import org.hibernate.query.sql.spi.NativeQueryImplementor; +import org.hibernate.resource.jdbc.spi.JdbcSessionContext; +import org.hibernate.resource.transaction.spi.TransactionCoordinator; + +import java.util.Set; +import java.util.TimeZone; +import java.util.UUID; + +/** + * A wrapper class that delegates all method invocations to a delegate instance of + * {@link SharedSessionContractImplementor}. This is useful for custom implementations + * of that API, so that only some methods need to be overridden + * + * @author Gavin King + */ +@SuppressWarnings("deprecation") +public class SharedSessionDelegatorBaseImpl implements SharedSessionContractImplementor { + + protected final SharedSessionContractImplementor delegate; + + public SharedSessionDelegatorBaseImpl(SessionImplementor delegate) { + this.delegate = delegate; + } + + /** + * Returns the delegate session. + */ + protected SharedSessionContract delegate() { + return delegate; + } + + @Override + public String getTenantIdentifier() { + return delegate.getTenantIdentifier(); + } + + private QueryProducerImplementor queryDelegate() { + return delegate; + } + + @Override + public MutationQuery createMutationQuery(@SuppressWarnings("rawtypes") CriteriaUpdate updateQuery) { + //noinspection resource + return delegate().createMutationQuery( updateQuery ); + } + + @Override + public MutationQuery createMutationQuery(@SuppressWarnings("rawtypes") CriteriaDelete deleteQuery) { + //noinspection resource + return delegate().createMutationQuery( deleteQuery ); + } + + @Override + public MutationQuery createMutationQuery(@SuppressWarnings("rawtypes") JpaCriteriaInsertSelect insertSelect) { + //noinspection resource + return delegate().createMutationQuery( insertSelect ); + } + + @Override + public QueryImplementor createQuery(CriteriaQuery criteriaQuery) { + return queryDelegate().createQuery( criteriaQuery ); + } + + @Override @SuppressWarnings("rawtypes") + public QueryImplementor createQuery(CriteriaUpdate updateQuery) { + return queryDelegate().createQuery( updateQuery ); + } + + @Override @SuppressWarnings("rawtypes") + public QueryImplementor createQuery(CriteriaDelete deleteQuery) { + return queryDelegate().createQuery( deleteQuery ); + } + + @Override @SuppressWarnings("rawtypes") + public QueryImplementor getNamedQuery(String name) { + return queryDelegate().getNamedQuery( name ); + } + + @Override @SuppressWarnings("rawtypes") + public NativeQueryImplementor getNamedNativeQuery(String name) { + return queryDelegate().getNamedNativeQuery( name ); + } + + @Override @SuppressWarnings("rawtypes") + public NativeQueryImplementor getNamedNativeQuery(String name, String resultSetMapping) { + return queryDelegate().getNamedNativeQuery( name, resultSetMapping ); + } + + @Override @SuppressWarnings("rawtypes") + public QueryImplementor createQuery(String queryString) { + return queryDelegate().createQuery( queryString ); + } + + @Override + public SelectionQuery createSelectionQuery(String hqlString) { + return queryDelegate().createSelectionQuery( hqlString ); + } + + @Override + public SelectionQuery createSelectionQuery(String hqlString, Class resultType) { + return queryDelegate().createSelectionQuery( hqlString, resultType ); + } + + @Override + public SelectionQuery createSelectionQuery(CriteriaQuery criteria) { + return queryDelegate().createSelectionQuery( criteria ); + } + + @Override + public QueryImplementor createQuery(String queryString, Class resultType) { + return queryDelegate().createQuery( queryString, resultType ); + } + + @Override @SuppressWarnings("rawtypes") + public QueryImplementor createNamedQuery(String name) { + return queryDelegate().createNamedQuery( name ); + } + + @Override + public QueryImplementor createNamedQuery(String name, Class resultClass) { + return queryDelegate().createNamedQuery( name, resultClass ); + } + + @Override + public SelectionQuery createNamedSelectionQuery(String name) { + //noinspection resource + return delegate().createNamedSelectionQuery( name ); + } + + @Override + public SelectionQuery createNamedSelectionQuery(String name, Class resultType) { + //noinspection resource + return delegate().createNamedSelectionQuery( name, resultType ); + } + + @Override @SuppressWarnings("rawtypes") + public NativeQueryImplementor createNativeQuery(String sqlString) { + return queryDelegate().createNativeQuery( sqlString ); + } + + @Override @SuppressWarnings({"rawtypes", "unchecked"}) + //note: we're doing something a bit funny here to work around + // the clashing signatures declared by the supertypes + public NativeQueryImplementor createNativeQuery(String sqlString, Class resultClass) { + return queryDelegate().createNativeQuery( sqlString, resultClass ); + } + + @Override + public NativeQueryImplementor createNativeQuery(String sqlString, Class resultClass, String tableAlias) { + return queryDelegate().createNativeQuery( sqlString, resultClass, tableAlias ); + } + + @Override @SuppressWarnings("rawtypes") + public NativeQueryImplementor createNativeQuery(String sqlString, String resultSetMappingName) { + return queryDelegate().createNativeQuery( sqlString, resultSetMappingName ); + } + + @Override + public NativeQueryImplementor createNativeQuery(String sqlString, String resultSetMappingName, Class resultClass) { + return queryDelegate().createNativeQuery( sqlString, resultSetMappingName, resultClass ); + } + + @Override + public MutationQuery createMutationQuery(String statementString) { + return delegate.createMutationQuery( statementString ); + } + + @Override + public MutationQuery createNamedMutationQuery(String name) { + return delegate.createNamedMutationQuery( name ); + } + + @Override + public MutationQuery createNativeMutationQuery(String sqlString) { + return delegate.createNativeMutationQuery( sqlString ); + } + + @Override + public ProcedureCall createNamedStoredProcedureQuery(String name) { + return delegate.createNamedStoredProcedureQuery( name ); + } + + @Override + public ProcedureCall createStoredProcedureQuery(String procedureName) { + return delegate.createStoredProcedureQuery( procedureName ); + } + + @Override + public ProcedureCall createStoredProcedureQuery(String procedureName, Class... resultClasses) { + return delegate.createStoredProcedureQuery( procedureName, resultClasses ); + } + + @Override + public ProcedureCall createStoredProcedureQuery(String procedureName, String... resultSetMappings) { + return delegate.createStoredProcedureQuery( procedureName, resultSetMappings ); + } + + @Override + public ProcedureCall getNamedProcedureCall(String name) { + return delegate.getNamedProcedureCall( name ); + } + + @Override + public ProcedureCall createStoredProcedureCall(String procedureName) { + return delegate.createStoredProcedureCall( procedureName ); + } + + @Override + public ProcedureCall createStoredProcedureCall(String procedureName, Class... resultClasses) { + return delegate.createStoredProcedureCall( procedureName, resultClasses ); + } + + @Override + public ProcedureCall createStoredProcedureCall(String procedureName, String... resultSetMappings) { + return delegate.createStoredProcedureCall( procedureName, resultSetMappings ); + } + + @Override + public void doWork(Work work) throws HibernateException { + delegate.doWork( work ); + } + + @Override + public T doReturningWork(ReturningWork work) throws HibernateException { + return delegate.doReturningWork( work ); + } + + @Override + public void close() throws HibernateException { + delegate.close(); + } + + @Override + public boolean isOpen() { + return delegate.isOpen(); + } + + @Override + public boolean isConnected() { + return delegate.isConnected(); + } + + @Override + public Transaction beginTransaction() { + return delegate.beginTransaction(); + } + + @Override + public Transaction getTransaction() { + return delegate.getTransaction(); + } + + @Override + public HibernateCriteriaBuilder getCriteriaBuilder() { + return delegate.getCriteriaBuilder(); + } + + @Override + public Integer getJdbcBatchSize() { + return delegate.getJdbcBatchSize(); + } + + @Override + public void setJdbcBatchSize(Integer jdbcBatchSize) { + delegate.setJdbcBatchSize( jdbcBatchSize ); + } + + @Override + public T execute(Callback callback) { + return delegate.execute( callback ); + } + + @Override + public SessionFactoryImplementor getFactory() { + return delegate.getFactory(); + } + + @Override + public SessionEventListenerManager getEventListenerManager() { + return delegate.getEventListenerManager(); + } + + @Override + public PersistenceContext getPersistenceContext() { + return delegate.getPersistenceContext(); + } + + @Override + public JdbcCoordinator getJdbcCoordinator() { + return delegate.getJdbcCoordinator(); + } + + @Override + public JdbcServices getJdbcServices() { + return delegate.getJdbcServices(); + } + + @Override + public UUID getSessionIdentifier() { + return delegate.getSessionIdentifier(); + } + + @Override + public boolean isClosed() { + return delegate.isClosed(); + } + + @Override + public void checkOpen(boolean markForRollbackIfClosed) { + delegate.checkOpen( markForRollbackIfClosed ); + } + + @Override + public void prepareForQueryExecution(boolean requiresTxn) { + delegate.prepareForQueryExecution( requiresTxn ); + } + + @Override + public void markForRollbackOnly() { + delegate.markForRollbackOnly(); + } + + @Override + public CacheTransactionSynchronization getCacheTransactionSynchronization() { + return delegate.getCacheTransactionSynchronization(); + } + + @Override + public boolean isTransactionInProgress() { + return delegate.isTransactionInProgress(); + } + + @Override + public Transaction accessTransaction() { + return delegate.accessTransaction(); + } + + @Override + public EntityKey generateEntityKey(Object id, EntityPersister persister) { + return delegate.generateEntityKey( id, persister ); + } + + @Override + public Interceptor getInterceptor() { + return delegate.getInterceptor(); + } + + @Override + public void setAutoClear(boolean enabled) { + delegate.setAutoClear( enabled ); + } + + @Override + public void initializeCollection(PersistentCollection collection, boolean writing) throws HibernateException { + delegate.initializeCollection( collection, writing ); + } + + @Override + public Object internalLoad(String entityName, Object id, boolean eager, boolean nullable) throws HibernateException { + return delegate.internalLoad( entityName, id, eager, nullable ); + } + + @Override + public Object immediateLoad(String entityName, Object id) throws HibernateException { + return delegate.immediateLoad( entityName, id ); + } + + @Override + public EntityPersister getEntityPersister(String entityName, Object object) throws HibernateException { + return delegate.getEntityPersister( entityName, object ); + } + + @Override + public Object getEntityUsingInterceptor(EntityKey key) throws HibernateException { + return delegate.getEntityUsingInterceptor( key ); + } + + @Override + public Object getContextEntityIdentifier(Object object) { + return delegate.getContextEntityIdentifier( object ); + } + + @Override + public String bestGuessEntityName(Object object) { + return delegate.bestGuessEntityName( object ); + } + + @Override + public String guessEntityName(Object entity) throws HibernateException { + return delegate.guessEntityName( entity ); + } + + @Override + public Object instantiate(String entityName, Object id) throws HibernateException { + return delegate.instantiate( entityName, id ); + } + + @Override + public Object instantiate(EntityPersister persister, Object id) throws HibernateException { + return delegate.instantiate( persister, id ); + } + + @Override + public boolean isDefaultReadOnly() { + return delegate.isDefaultReadOnly(); + } + + @Override + public CacheMode getCacheMode() { + return delegate.getCacheMode(); + } + + @Override + public void setCacheMode(CacheMode cm) { + delegate.setCacheMode( cm ); + } + + @Override + public void setCriteriaCopyTreeEnabled(boolean jpaCriteriaCopyComplianceEnabled) { + delegate.setCriteriaCopyTreeEnabled( jpaCriteriaCopyComplianceEnabled ); + } + + @Override + public boolean isCriteriaCopyTreeEnabled() { + return delegate.isCriteriaCopyTreeEnabled(); + } + + @Override + public FlushModeType getFlushMode() { + return delegate.getFlushMode(); + } + + @Override + public void setHibernateFlushMode(FlushMode flushMode) { + delegate.setHibernateFlushMode( flushMode ); + } + + @Override + public FlushMode getHibernateFlushMode() { + return delegate.getHibernateFlushMode(); + } + + @Override + public void flush() { + delegate.flush(); + } + + @Override + public void afterScrollOperation() { + delegate.afterScrollOperation(); + } + + @Override + public boolean shouldAutoClose() { + return delegate.shouldAutoClose(); + } + + @Override + public boolean isAutoCloseSessionEnabled() { + return delegate.isAutoCloseSessionEnabled(); + } + + @Override + public LoadQueryInfluencers getLoadQueryInfluencers() { + return delegate.getLoadQueryInfluencers(); + } + + @Override + public ExceptionConverter getExceptionConverter() { + return delegate.getExceptionConverter(); + } + + @Override + public PersistenceContext getPersistenceContextInternal() { + return delegate.getPersistenceContextInternal(); + } + + @Override + public boolean autoFlushIfRequired(Set querySpaces) throws HibernateException { + return delegate.autoFlushIfRequired( querySpaces ); + } + + @Override + public void afterOperation(boolean success) { + delegate.afterOperation( success ); + } + + @Override + public JdbcSessionContext getJdbcSessionContext() { + return delegate.getJdbcSessionContext(); + } + + @Override + public JdbcConnectionAccess getJdbcConnectionAccess() { + return delegate.getJdbcConnectionAccess(); + } + + @Override + public TransactionCoordinator getTransactionCoordinator() { + return delegate.getTransactionCoordinator(); + } + + @Override + public void startTransactionBoundary() { + delegate.startTransactionBoundary(); + } + + @Override + public void afterTransactionBegin() { + delegate.afterTransactionBegin(); + } + + @Override + public void beforeTransactionCompletion() { + delegate.beforeTransactionCompletion(); + } + + @Override + public void afterTransactionCompletion(boolean successful, boolean delayed) { + delegate.afterTransactionCompletion( successful, delayed ); + } + + @Override + public void flushBeforeTransactionCompletion() { + delegate.flushBeforeTransactionCompletion(); + } + + @Override + public boolean shouldAutoJoinTransaction() { + return delegate.shouldAutoJoinTransaction(); + } + + @Override + public boolean useStreamForLobBinding() { + return delegate.useStreamForLobBinding(); + } + + @Override + public int getPreferredSqlTypeCodeForBoolean() { + return delegate.getPreferredSqlTypeCodeForBoolean(); + } + + @Override + public LobCreator getLobCreator() { + return delegate.getLobCreator(); + } + + @Override + public TimeZone getJdbcTimeZone() { + return delegate.getJdbcTimeZone(); + } +}