Hibernate ORM and Hibernate Reactive cannot be used in the same application fixes #13425

#13425

* Use DataSourcesReactiveBuildTimeConfig to understand if the default data source supports reactive to avoid failing while using reactive and blocking together
* ORMReactiveCompatbilityUnitTest - Tests are included for default data source / PU, named Datasource and named PU
* Removed ReactivePersistenceUnit annotation, generated the Mutiny.SessionFactory bean in the extension itself
* Avoid concurrent access to recorded state while booting FastBootHibernatePersistenceProvider and FastBootHibernateReactivePersistenceProvider in this order (it used to pop the recorded state effectively removing from the other BootProvider)
* add quarkus.hibernate-orm.blocking configuration and test
* Unused method generateSchema moved to throw an Exception
* Avoid running database schema migration twice when using reactive and persisting together
* Upgraded documentation

Author: lucamolteni

docs/src/main/asciidoc/hibernate-reactive.adoc

@@ -112,6 +112,8 @@ quarkus.hibernate-orm.database.generation=drop-and-create
 Note that these configuration properties are not the same ones as in your typical Hibernate Reactive configuration file.
 They will often map to Hibernate Reactive configuration properties but could have different names and don't necessarily map 1:1 to each other.
 
+Blocking (non-reactive) and reactive configuration can be mixed together in the same project. You can take an example from the Quarkus' integration test `quarkus-integration-test-hibernate-reactive-orm-compatibility`
+
 Also, Quarkus will set many Hibernate Reactive configuration settings automatically, and will often use more modern defaults.
 
 WARNING: Configuring Hibernate Reactive using the standard `persistence.xml` configuration file is not supported.
@@ -321,8 +323,6 @@ or even a single named persistence unit.
 or xref:hibernate-orm.adoc#schema-approach[schema-based multitenancy] at the moment.
 xref:hibernate-orm.adoc#discriminator-approach[Discriminator-based multitenancy], on the other hand, is expected to work correctly.
 See https://github.com/quarkusio/quarkus/issues/15959.
-* This extension cannot be used at the same time as Hibernate ORM.
-See https://github.com/quarkusio/quarkus/issues/13425.
 * Integration with the Envers extension is not supported.
 * Transaction demarcation cannot be done using `jakarta.transaction.Transactional` or `QuarkusTransaction`;
 if you use xref:hibernate-reactive-panache.adoc[Hibernate Reactive with Panache],

extensions/hibernate-orm/deployment/src/main/java/io/quarkus/hibernate/orm/deployment/HibernateOrmCdiProcessor.java

@@ -1,10 +1,6 @@
 package io.quarkus.hibernate.orm.deployment;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Locale;
-import java.util.Set;
+import java.util.*;
 import java.util.stream.Collectors;
 
 import jakarta.enterprise.context.ApplicationScoped;
@@ -214,6 +210,7 @@ void generateDataSourceBeans(HibernateOrmRecorder recorder,
             return;
         }
 
+        Set<String> createdSessionFactory = new HashSet<>();
         for (PersistenceUnitDescriptorBuildItem persistenceUnitDescriptor : persistenceUnitDescriptors) {
             String persistenceUnitName = persistenceUnitDescriptor.getPersistenceUnitName();
             // Hibernate Reactive does not use the same name for its default persistence unit,
@@ -222,14 +219,30 @@ void generateDataSourceBeans(HibernateOrmRecorder recorder,
             String persistenceUnitConfigName = persistenceUnitDescriptor.getConfigurationName();
             boolean isDefaultPU = PersistenceUnitUtil.isDefaultPersistenceUnit(persistenceUnitConfigName);
             boolean isNamedPU = !isDefaultPU;
-
-            syntheticBeanBuildItemBuildProducer
-                    .produce(createSyntheticBean(persistenceUnitName,
-                            isDefaultPU, isNamedPU,
-                            SessionFactory.class, SESSION_FACTORY_EXPOSED_TYPES, true)
-                            .createWith(recorder.sessionFactorySupplier(persistenceUnitName))
-                            .addInjectionPoint(ClassType.create(DotName.createSimple(JPAConfig.class)))
-                            .done());
+            boolean isReactive = persistenceUnitDescriptor.isReactive();
+
+            ExtendedBeanConfigurator persistenceUnitBean = createSyntheticBean(persistenceUnitName,
+                    isDefaultPU,
+                    isNamedPU,
+                    SessionFactory.class,
+                    SESSION_FACTORY_EXPOSED_TYPES,
+                    true);
+
+            // A few cases here:
+            // - We only have a PersistenceUnitDescriptorBuildItem, and it's blocking, we create the SessionFactory
+            // - We only have a PersistenceUnitDescriptorBuildItem, and it's reactive, we create the Blocking SessionFactory anyway, as it might be used
+            //   to gather metadata such as the configuration from it see io/quarkus/hibernate/reactive/compatbility/CompatibilityUnitTestBase.testBlockingDisabled
+            //   The Mutiny.SessionFactory API doesn't expose every method the Hibernate SessionFactory does, hence this hack
+            // - We have multiple PersistenceUnitDescriptorBuildItem, (Reactive + Hibernate scenario), we want to make sure this is created only once
+            //   with the correct info from the blocking PersistenceUnitDescriptorBuildItem
+            if (!createdSessionFactory.contains(persistenceUnitName)
+                    && (!isReactive || persistenceUnitDescriptors.size() == 1)) {
+                syntheticBeanBuildItemBuildProducer
+                        .produce(persistenceUnitBean
+                                .createWith(recorder.sessionFactorySupplier(persistenceUnitName))
+                                .addInjectionPoint(ClassType.create(DotName.createSimple(JPAConfig.class)))
+                                .done());
+            }
 
             if (capabilities.isPresent(Capability.TRANSACTIONS)
                     && capabilities.isMissing(Capability.HIBERNATE_REACTIVE)) {

extensions/hibernate-orm/deployment/src/main/java/io/quarkus/hibernate/orm/deployment/HibernateOrmConfig.java

@@ -34,6 +34,19 @@ public interface HibernateOrmConfig {
     @WithDefault("true")
     boolean enabled();
 
+    /**
+     * Whether Hibernate ORM is working in blocking mode.
+     *
+     * Think of this as enabling ORM usage while using Hibernate Reactive.
+     * While using Hibernate ORM and Hibernate Reactive together, blocking is usually disabled when not providing the
+     * JDBC driver, but if for whatever reason you want to provide the JDBC driver and still block the usage of
+     * Hibernate ORM, you can use this property.
+     *
+     * @asciidoclet
+     */
+    @WithDefault("true")
+    boolean blocking();
+
     /**
      * Database related configuration.
      */

extensions/hibernate-orm/deployment/src/main/java/io/quarkus/hibernate/orm/deployment/HibernateOrmProcessor.java

@@ -286,14 +286,11 @@ public void parsePersistenceXmlDescriptors(HibernateOrmConfig config,
     public ImpliedBlockingPersistenceUnitTypeBuildItem defineTypeOfImpliedPU(
             List<JdbcDataSourceBuildItem> jdbcDataSourcesBuildItem, //This is from Agroal SPI: safe to use even for Hibernate Reactive
             Capabilities capabilities) {
-        // If we have some blocking datasources defined, we can have an implied PU
-        if (capabilities.isPresent(Capability.HIBERNATE_REACTIVE)) {
+        if (capabilities.isPresent(Capability.HIBERNATE_REACTIVE) && jdbcDataSourcesBuildItem.isEmpty()) {
             // if we don't have any blocking datasources and Hibernate Reactive is present,
             // we don't want a blocking persistence unit
             return ImpliedBlockingPersistenceUnitTypeBuildItem.none();
         } else {
-            // even if we don't have any JDBC datasource, we trigger the implied blocking persistence unit
-            // to properly trigger error conditions and error messages to guide the user
             return ImpliedBlockingPersistenceUnitTypeBuildItem.generateImpliedPersistenceUnit();
         }
     }
@@ -351,7 +348,7 @@ public void configurationDescriptorBuilding(
                                     hibernateOrmConfig.database().ormCompatibilityVersion(), Collections.emptyMap()),
                             null,
                             jpaModel.getXmlMappings(persistenceXmlDescriptorBuildItem.getDescriptor().getName()),
-                            false, true, isHibernateValidatorPresent(capabilities), jsonMapper, xmlMapper));
+                            true, isHibernateValidatorPresent(capabilities), jsonMapper, xmlMapper));
         }
 
         if (impliedPU.shouldGenerateImpliedBlockingPersistenceUnit()) {
@@ -667,7 +664,7 @@ public PersistenceProviderSetUpBuildItem setupPersistenceProvider(HibernateOrmRe
             Capabilities capabilities, HibernateOrmRuntimeConfig hibernateOrmRuntimeConfig,
             List<HibernateOrmIntegrationRuntimeConfiguredBuildItem> integrationBuildItems,
             BuildProducer<RecorderBeanInitializedBuildItem> orderEnforcer) {
-        if (capabilities.isMissing(Capability.HIBERNATE_REACTIVE)) {
+        if (capabilities.isPresent(Capability.AGROAL)) {
             recorder.setupPersistenceProvider(hibernateOrmRuntimeConfig,
                     HibernateOrmIntegrationRuntimeConfiguredBuildItem.collectDescriptors(integrationBuildItems));
         }
@@ -862,6 +859,12 @@ private void handleHibernateORMWithNoPersistenceXml(
             }
         }
 
+        if (!hibernateOrmConfig.blocking()) {
+            LOG.infof(
+                    "Hibernate ORM was disabled explicitly by quarkus.hibernate-orm.blocking=false");
+            return;
+        }
+
         Optional<JdbcDataSourceBuildItem> defaultJdbcDataSource = jdbcDataSources.stream()
                 .filter(i -> i.isDefault())
                 .findFirst();
@@ -952,7 +955,8 @@ private static void producePersistenceUnitDescriptorFromConfig(
                 // - the comment at org/hibernate/boot/model/process/internal/ScanningCoordinator.java:246:
                 //   "IMPL NOTE : "explicitlyListedClassNames" can contain class or package names..."
                 new ArrayList<>(modelClassesAndPackages),
-                new Properties());
+                new Properties(),
+                false);
 
         MultiTenancyStrategy multiTenancyStrategy = getMultiTenancyStrategy(persistenceUnitConfig.multitenant());
         collectDialectConfig(persistenceUnitName, persistenceUnitConfig,
@@ -1147,7 +1151,7 @@ private static void producePersistenceUnitDescriptorFromConfig(
                                 persistenceUnitConfig.unsupportedProperties()),
                         persistenceUnitConfig.multitenantSchemaDatasource().orElse(null),
                         xmlMappings,
-                        false, false,
+                        false,
                         isHibernateValidatorPresent(capabilities), jsonMapper, xmlMapper));
     }
 

extensions/hibernate-orm/deployment/src/main/java/io/quarkus/hibernate/orm/deployment/PersistenceUnitDescriptorBuildItem.java

@@ -25,7 +25,6 @@ public final class PersistenceUnitDescriptorBuildItem extends MultiBuildItem {
     private final RecordedConfig config;
     private final String multiTenancySchemaDataSource;
     private final List<RecordableXmlMapping> xmlMappings;
-    private final boolean isReactive;
     private final boolean fromPersistenceXml;
     private final boolean isHibernateValidatorPresent;
     private final Optional<FormatMapperKind> jsonMapper;
@@ -35,13 +34,12 @@ public PersistenceUnitDescriptorBuildItem(QuarkusPersistenceUnitDescriptor descr
             RecordedConfig config,
             String multiTenancySchemaDataSource,
             List<RecordableXmlMapping> xmlMappings,
-            boolean isReactive, boolean fromPersistenceXml,
+            boolean fromPersistenceXml,
             boolean isHibernateValidatorPresent, Optional<FormatMapperKind> jsonMapper, Optional<FormatMapperKind> xmlMapper) {
         this.descriptor = descriptor;
         this.config = config;
         this.multiTenancySchemaDataSource = multiTenancySchemaDataSource;
         this.xmlMappings = xmlMappings;
-        this.isReactive = isReactive;
         this.fromPersistenceXml = fromPersistenceXml;
         this.isHibernateValidatorPresent = isHibernateValidatorPresent;
         this.jsonMapper = jsonMapper;
@@ -80,14 +78,18 @@ public boolean isFromPersistenceXml() {
         return fromPersistenceXml;
     }
 
+    public boolean isReactive() {
+        return descriptor.isReactive();
+    }
+
     public boolean isHibernateValidatorPresent() {
         return isHibernateValidatorPresent;
     }
 
     public QuarkusPersistenceUnitDefinition asOutputPersistenceUnitDefinition(
             List<HibernateOrmIntegrationStaticDescriptor> integrationStaticDescriptors) {
         return new QuarkusPersistenceUnitDefinition(descriptor, config,
-                xmlMappings, isReactive, fromPersistenceXml, isHibernateValidatorPresent,
-                jsonMapper, xmlMapper, integrationStaticDescriptors);
+                xmlMappings, fromPersistenceXml, isHibernateValidatorPresent, jsonMapper, xmlMapper,
+                integrationStaticDescriptors);
     }
 }

extensions/hibernate-orm/deployment/src/test/java/io/quarkus/hibernate/orm/multiplepersistenceunits/MultiplePersistenceUnitsCdiEntityManagerTest.java

@@ -7,10 +7,12 @@
 import jakarta.enterprise.context.ContextNotActiveException;
 import jakarta.enterprise.context.control.ActivateRequestContext;
 import jakarta.inject.Inject;
+import jakarta.inject.Named;
 import jakarta.persistence.EntityManager;
 import jakarta.persistence.TransactionRequiredException;
 import jakarta.transaction.Transactional;
 
+import org.hibernate.SessionFactory;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 
@@ -41,6 +43,18 @@ public class MultiplePersistenceUnitsCdiEntityManagerTest {
     @PersistenceUnit("inventory")
     EntityManager inventoryEntityManager;
 
+    // The following sessionFactories are not used in tests but needs to be correctly created, if not the test will fail
+    @Inject
+    SessionFactory defaultSessionFactory;
+
+    @Inject
+    @Named("users")
+    SessionFactory usersFactory;
+
+    @Inject
+    @Named("inventory")
+    SessionFactory inventoryFactory;
+
     @Test
     @Transactional
     public void defaultEntityManagerInTransaction() {

extensions/hibernate-orm/runtime/src/main/java/io/quarkus/hibernate/orm/runtime/FastBootHibernatePersistenceProvider.java

@@ -165,11 +165,12 @@ private EntityManagerFactoryBuilder getEntityManagerFactoryBuilderOrNull(String
                 continue;
             }
 
-            RecordedState recordedState = PersistenceUnitsHolder.popRecordedState(persistenceUnitName);
+            RecordedState recordedState = PersistenceUnitsHolder.getRecordedState(persistenceUnitName);
 
             if (recordedState.isReactive()) {
-                throw new IllegalStateException(
-                        "Attempting to boot a blocking Hibernate ORM instance on a reactive RecordedState");
+                log.debug(
+                        "Ignoring reactive RecordedState in FastBootHibernatePersistenceProvider, it'll be handled in FastBootHibernateReactivePersistenceProvider");
+                continue;
             }
             final PrevalidatedQuarkusMetadata metadata = recordedState.getMetadata();
             var puConfig = hibernateOrmRuntimeConfig.persistenceUnits().get(persistenceUnit.getConfigurationName());
@@ -190,7 +191,8 @@ private EntityManagerFactoryBuilder getEntityManagerFactoryBuilderOrNull(String
                     metadata /* Uses the StandardServiceRegistry references by this! */,
                     standardServiceRegistry /* Mostly ignored! (yet needs to match) */,
                     runtimeSettings,
-                    validatorFactory, cdiBeanManager, recordedState.getMultiTenancyStrategy());
+                    validatorFactory, cdiBeanManager, recordedState.getMultiTenancyStrategy(),
+                    true);
         }
 
         log.debug("Found no matching persistence units");

extensions/hibernate-orm/runtime/src/main/java/io/quarkus/hibernate/orm/runtime/MultiplePersistenceProviderResolver.java

@@ -0,0 +1,32 @@
+package io.quarkus.hibernate.orm.runtime;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import jakarta.persistence.spi.PersistenceProvider;
+import jakarta.persistence.spi.PersistenceProviderResolver;
+
+public final class MultiplePersistenceProviderResolver implements PersistenceProviderResolver {
+
+    private final List<PersistenceProvider> persistenceProviders = new ArrayList<>();
+
+    public MultiplePersistenceProviderResolver(PersistenceProvider... persistenceProviders) {
+        this.persistenceProviders.addAll(List.of(persistenceProviders));
+    }
+
+    @Override
+    public List<PersistenceProvider> getPersistenceProviders() {
+        return Collections.unmodifiableList(persistenceProviders);
+    }
+
+    public void addPersistenceProvider(PersistenceProvider persistenceProvider) {
+        persistenceProviders.add(persistenceProvider);
+    }
+
+    @Override
+    public void clearCachedProviders() {
+        // done!
+    }
+
+}

extensions/hibernate-orm/runtime/src/main/java/io/quarkus/hibernate/orm/runtime/PersistenceProviderSetup.java

@@ -3,6 +3,9 @@
 import java.util.List;
 import java.util.Map;
 
+import jakarta.persistence.spi.PersistenceProviderResolver;
+import jakarta.persistence.spi.PersistenceProviderResolverHolder;
+
 import io.quarkus.hibernate.orm.runtime.integration.HibernateOrmIntegrationRuntimeDescriptor;
 
 public final class PersistenceProviderSetup {
@@ -18,8 +21,19 @@ public static void registerStaticInitPersistenceProvider() {
 
     public static void registerRuntimePersistenceProvider(HibernateOrmRuntimeConfig hibernateOrmRuntimeConfig,
             Map<String, List<HibernateOrmIntegrationRuntimeDescriptor>> integrationRuntimeDescriptors) {
-        jakarta.persistence.spi.PersistenceProviderResolverHolder.setPersistenceProviderResolver(
-                new SingletonPersistenceProviderResolver(
-                        new FastBootHibernatePersistenceProvider(hibernateOrmRuntimeConfig, integrationRuntimeDescriptors)));
+
+        PersistenceProviderResolver persistenceProviderResolver = PersistenceProviderResolverHolder
+                .getPersistenceProviderResolver();
+        if (persistenceProviderResolver == null ||
+                (persistenceProviderResolver != null
+                        && !(persistenceProviderResolver instanceof MultiplePersistenceProviderResolver))) {
+            persistenceProviderResolver = new MultiplePersistenceProviderResolver();
+            PersistenceProviderResolverHolder.setPersistenceProviderResolver(persistenceProviderResolver);
+        }
+
+        ((MultiplePersistenceProviderResolver) persistenceProviderResolver)
+                .addPersistenceProvider(new FastBootHibernatePersistenceProvider(hibernateOrmRuntimeConfig,
+                        integrationRuntimeDescriptors));
+
     }
 }

extensions/hibernate-orm/runtime/src/main/java/io/quarkus/hibernate/orm/runtime/PersistenceUnitsHolder.java

@@ -48,13 +48,13 @@ public static List<QuarkusPersistenceUnitDescriptor> getPersistenceUnitDescripto
         return persistenceUnits.units;
     }
 
-    public static RecordedState popRecordedState(String persistenceUnitName) {
+    public static RecordedState getRecordedState(String persistenceUnitName) {
         checkJPAInitialization();
         Object key = persistenceUnitName;
         if (persistenceUnitName == null) {
             key = NO_NAME_TOKEN;
         }
-        return persistenceUnits.recordedStates.remove(key);
+        return persistenceUnits.recordedStates.get(key);
     }
 
     private static List<QuarkusPersistenceUnitDescriptor> convertPersistenceUnits(