Merge pull request #50146 from yrodiere/i50141

Simplify inference of the SupportedDbKind and avoid NoClassDefFoundError on `CommunityDatabase`

Author: gsmet

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

@@ -1056,7 +1056,6 @@ private static Optional<DatabaseKind.SupportedDatabaseKind> collectDialectConfig
                 explicitDbMinVersion,
                 dialectConfig,
                 dbKindMetadataBuildItems,
-                persistenceUnitConfig.dialect().storageEngine(),
                 systemProperties,
                 puPropertiesCollector,
                 storageEngineCollector);

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

@@ -26,8 +26,6 @@
 import jakarta.persistence.ValidationMode;
 
 import org.hibernate.cfg.AvailableSettings;
-import org.hibernate.community.dialect.CommunityDatabase;
-import org.hibernate.dialect.Database;
 import org.hibernate.id.SequenceMismatchStrategy;
 import org.hibernate.jpa.boot.spi.JpaSettings;
 import org.hibernate.jpa.boot.spi.PersistenceUnitDescriptor;
@@ -103,7 +101,6 @@ public static Optional<SupportedDatabaseKind> setDialectAndStorageEngine(
             Optional<String> explicitDbMinVersion,
             HibernateOrmConfigPersistenceUnit.HibernateOrmConfigPersistenceUnitDialect dialectConfig,
             List<DatabaseKindDialectBuildItem> dbKindDialectBuildItems,
-            Optional<String> storageEngine,
             BuildProducer<SystemPropertyBuildItem> systemProperties,
             BiConsumer<String, String> puPropertiesCollector,
             Set<String> storageEngineCollector) {
@@ -115,6 +112,9 @@ public static Optional<SupportedDatabaseKind> setDialectAndStorageEngine(
             for (DatabaseKindDialectBuildItem item : dbKindDialectBuildItems) {
                 if (dbKind.isPresent() && DatabaseKind.is(dbKind.get(), item.getDbKind())
                         || explicitDialect.isPresent() && item.getMatchingDialects().contains(explicitDialect.get())) {
+                    if (dbKind.isEmpty()) {
+                        dbKind = Optional.ofNullable(item.getDbKind());
+                    }
                     dbProductName = item.getDatabaseProductName();
                     if (dbProductName.isEmpty() && explicitDialect.isEmpty()) {
                         dialect = item.getDialectOptional();
@@ -145,29 +145,26 @@ public static Optional<SupportedDatabaseKind> setDialectAndStorageEngine(
             puPropertiesCollector.accept(AvailableSettings.JAKARTA_HBM2DDL_DB_VERSION, dbProductVersion.get());
         }
 
-        Optional<SupportedDatabaseKind> supportedDatabaseKind = handleDialectSpecificSettings(
+        Optional<SupportedDatabaseKind> supportedDbKind = dbKind.flatMap(SupportedDatabaseKind::from);
+
+        handleDialectSpecificSettings(
                 persistenceUnitName,
                 systemProperties,
                 puPropertiesCollector,
                 storageEngineCollector,
                 dialectConfig,
-                dbKind,
-                dbProductName);
+                supportedDbKind);
 
-        return supportedDatabaseKind;
+        return supportedDbKind;
     }
 
-    private static Optional<SupportedDatabaseKind> handleDialectSpecificSettings(
+    private static void handleDialectSpecificSettings(
             String persistenceUnitName,
             BuildProducer<SystemPropertyBuildItem> systemProperties,
             BiConsumer<String, String> puPropertiesCollector,
             Set<String> storageEngineCollector,
             HibernateOrmConfigPersistenceUnit.HibernateOrmConfigPersistenceUnitDialect dialectConfig,
-            Optional<String> dbKind,
-            Optional<String> dbProductName) {
-
-        final Optional<SupportedDatabaseKind> databaseKind = determineDatabaseKind(dbKind, dbProductName);
-
+            Optional<SupportedDatabaseKind> databaseKind) {
         handleStorageEngine(databaseKind, persistenceUnitName, dialectConfig, storageEngineCollector,
                 systemProperties);
 
@@ -215,53 +212,6 @@ private static Optional<SupportedDatabaseKind> handleDialectSpecificSettings(
                         puPropertiesCollector);
             }
         }
-
-        return databaseKind;
-    }
-
-    private static Optional<SupportedDatabaseKind> determineDatabaseKind(
-            Optional<String> dbKindOptional,
-            Optional<String> dbProductNameOptional) {
-
-        Optional<SupportedDatabaseKind> supportedDatabaseKindFromDBKind = dbKindOptional.flatMap(SupportedDatabaseKind::from);
-
-        return supportedDatabaseKindFromDBKind.or(() -> supportedDatabaseKindFromProductName(dbProductNameOptional));
-    }
-
-    private static Optional<SupportedDatabaseKind> supportedDatabaseKindFromProductName(
-            Optional<String> dbProductNameOptional) {
-
-        return dbProductNameOptional
-                .filter(s -> !s.isEmpty())
-                .flatMap(dbProductName -> {
-
-                    if (Database.DB2.productNameMatches(dbProductName)) {
-                        return Optional.of(SupportedDatabaseKind.DB2);
-                    }
-                    if (CommunityDatabase.DERBY.productNameMatches(dbProductName)) {
-                        return Optional.of(SupportedDatabaseKind.DERBY);
-                    }
-                    if (Database.H2.productNameMatches(dbProductName)) {
-                        return Optional.of(SupportedDatabaseKind.H2);
-                    }
-                    if (Database.MARIADB.productNameMatches(dbProductName)) {
-                        return Optional.of(SupportedDatabaseKind.MARIADB);
-                    }
-                    if (Database.MYSQL.productNameMatches(dbProductName)) {
-                        return Optional.of(SupportedDatabaseKind.MYSQL);
-                    }
-                    if (Database.ORACLE.productNameMatches(dbProductName)) {
-                        return Optional.of(SupportedDatabaseKind.ORACLE);
-                    }
-                    if (Database.POSTGRESQL.productNameMatches(dbProductName)) {
-                        return Optional.of(SupportedDatabaseKind.POSTGRESQL);
-                    }
-                    if (Database.SQLSERVER.productNameMatches(dbProductName)) {
-                        return Optional.of(SupportedDatabaseKind.MSSQL);
-                    }
-                    return Optional.empty();
-
-                });
     }
 
     private static void handleStorageEngine(

extensions/hibernate-reactive/deployment/src/main/java/io/quarkus/hibernate/reactive/deployment/HibernateReactiveProcessor.java

@@ -392,7 +392,6 @@ private static QuarkusPersistenceUnitDescriptorWithSupportedDBKind generateReact
                 explicitDbMinVersion,
                 dialectConfig,
                 dbKindDialectBuildItems,
-                persistenceUnitConfig.dialect().storageEngine(),
                 systemProperties,
                 descriptor.getProperties()::setProperty,
                 storageEngineCollector);