merge master

build.gradle

@@ -86,7 +86,7 @@ task ciBuild {
 
 
 wrapper {
-	gradleVersion = '4.10.2'
+	gradleVersion = '4.10.3'
 	distributionType = Wrapper.DistributionType.ALL
 }
 

databases/hana/matrix.gradle

@@ -5,4 +5,4 @@
  * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
  */
 
-jdbcDependency 'com.sap.cloud.db.jdbc:ngdbc:2.2.16'
+jdbcDependency 'com.sap.cloud.db.jdbc:ngdbc:2.4.59'

databases/mariadb/matrix.gradle

@@ -4,4 +4,4 @@
  * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
  * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
  */
-jdbcDependency 'org.mariadb.jdbc:mariadb-java-client:1.5.7'
+jdbcDependency 'org.mariadb.jdbc:mariadb-java-client:2.2.4'

documentation/src/main/asciidoc/userguide/chapters/jdbc/Database_Access.adoc

@@ -39,6 +39,14 @@ The `DataSource` `ConnectionProvider` also (optionally) accepts the `hibernate.c
 If specified, the https://docs.oracle.com/javase/8/docs/api/javax/sql/DataSource.html#getConnection-java.lang.String-java.lang.String-[`DataSource#getConnection(String username, String password)`] will be used.
 Otherwise, the no-arg form is used.
 
+[[database-connectionprovider-driver]]
+=== Driver Configuration
+`hibernate.connection.driver_class`:: The name of the JDBC Driver class to use
+`hibernate.connection.url`:: The JDBC connection url
+`hibernate.connection.*`:: All such setting names (except the <<appendices/Configurations.adoc#configurations-database-connection,predefined ones>>) will have the `hibernate.connection.` prefix stripped. The remaining name and the original value will be passed to the driver as a JDBC connection property
+
+NOTE: Not all properties apply to all situations. For example, if you are providing a data source, `hibernate.connection.driver_class` setting will not be used.
+
 [[database-connectionprovider-c3p0]]
 === Using c3p0
 
@@ -48,13 +56,10 @@ To use the c3p0 integration, the application must include the `hibernate-c3p0` m
 ====
 
 Hibernate also provides support for applications to use http://www.mchange.com/projects/c3p0/[c3p0] connection pooling.
-When using this c3p0 support, a number of additional configuration settings are recognized.
+When c3p0 support is enabled, a number of c3p0-specific configuration settings are recognized in addition to the general ones described in <<database-connectionprovider-driver>>.
 
 Transaction isolation of the Connections is managed by the `ConnectionProvider` itself. See <<database-connectionprovider-isolation>>.
 
-`hibernate.connection.driver_class`:: The name of the JDBC Driver class to use
-`hibernate.connection.url`:: The JDBC connection url.
-Any settings prefixed with `hibernate.connection.` (other than the "special ones"):: These all have the `hibernate.connection.` prefix stripped and the rest will be passed as JDBC connection properties
 `hibernate.c3p0.min_size` or `c3p0.minPoolSize`:: The minimum size of the c3p0 pool. See http://www.mchange.com/projects/c3p0/#minPoolSize[c3p0 minPoolSize]
 `hibernate.c3p0.max_size` or `c3p0.maxPoolSize`:: The maximum size of the c3p0 pool. See http://www.mchange.com/projects/c3p0/#maxPoolSize[c3p0 maxPoolSize]
 `hibernate.c3p0.timeout` or `c3p0.maxIdleTime`:: The Connection idle time. See http://www.mchange.com/projects/c3p0/#maxIdleTime[c3p0 maxIdleTime]

gradle/libraries.gradle

@@ -28,11 +28,11 @@ ext {
     geolatteVersion = '1.4.0'
 
     // Wildfly version targeted by module ZIP; Arquillian/Shrinkwrap versions used for CDI testing and testing the module ZIP
-    wildflyVersion = '14.0.1.Final'
-    arquillianVersion = '1.4.0.Final'
+    wildflyVersion = '17.0.1.Final'
+    arquillianVersion = '1.4.1.Final'
     shrinkwrapVersion = '1.2.6'
     shrinkwrapDescriptorsVersion = '2.0.0'
-    wildflyArquillianContainerVersion = '2.1.1.Final'
+    wildflyArquillianContainerVersion = '2.2.0.Final'
 
     jodaTimeVersion = '2.3'
 
@@ -109,8 +109,7 @@ ext {
             hsqldb:          "org.hsqldb:hsqldb:2.3.2",
             derby:           "org.apache.derby:derby:10.11.1.1",
             postgresql:      'org.postgresql:postgresql:42.2.2',
-            //Upgrade MySQL Driver only when this issue gets fixed: https://bugs.mysql.com/bug.php?id=85941
-            mysql:           'mysql:mysql-connector-java:5.1.46',
+            mysql:           'mysql:mysql-connector-java:8.0.17',
             mariadb:         'org.mariadb.jdbc:mariadb-java-client:2.2.3',
 
             oracle:          'com.oracle.jdbc:ojdbc8:12.2.0.1',
@@ -159,7 +158,7 @@ ext {
             wildfly_arquillian_container_managed: "org.wildfly.arquillian:wildfly-arquillian-container-managed:${wildflyArquillianContainerVersion}",
             jboss_vfs: "org.jboss:jboss-vfs:3.2.11.Final",
             jipijapa_spi: "org.wildfly:jipijapa-spi:${wildflyVersion}",
-            wildfly_transaction_client : 'org.wildfly.transaction:wildfly-transaction-client:1.0.3.Final',
+            wildfly_transaction_client : 'org.wildfly.transaction:wildfly-transaction-client:1.1.7.Final',
 
             jboss_ejb_spec_jar          : 'org.jboss.spec.javax.ejb:jboss-ejb-api_3.2_spec:1.0.0.Final',
             jboss_annotation_spec_jar   : 'org.jboss.spec.javax.annotation:jboss-annotations-api_1.2_spec:1.0.0.Final'

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.2-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.3-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

hibernate-core/src/main/java/org/hibernate/boot/internal/SessionFactoryOptionsBuilder.java

@@ -99,6 +99,7 @@
 import static org.hibernate.cfg.AvailableSettings.MAX_FETCH_DEPTH;
 import static org.hibernate.cfg.AvailableSettings.MULTI_TENANT_IDENTIFIER_RESOLVER;
 import static org.hibernate.cfg.AvailableSettings.NATIVE_EXCEPTION_HANDLING_51_COMPLIANCE;
+import static org.hibernate.cfg.AvailableSettings.OMIT_JOIN_OF_SUPERCLASS_TABLES;
 import static org.hibernate.cfg.AvailableSettings.ORDER_INSERTS;
 import static org.hibernate.cfg.AvailableSettings.JPA_CALLBACKS_ENABLED;
 import static org.hibernate.cfg.AvailableSettings.ORDER_UPDATES;
@@ -212,6 +213,7 @@ public class SessionFactoryOptionsBuilder implements SessionFactoryOptions {
 	private final boolean procedureParameterNullPassingEnabled;
 	private final boolean collectionJoinSubqueryRewriteEnabled;
 	private boolean jdbcStyleParamsZeroBased;
+	private final boolean omitJoinOfSuperclassTablesEnabled;
 
 	// Caching
 	private boolean secondLevelCacheEnabled;
@@ -360,6 +362,7 @@ public SessionFactoryOptionsBuilder(StandardServiceRegistry serviceRegistry, Boo
 				CONVENTIONAL_JAVA_CONSTANTS, BOOLEAN, true );
 		this.procedureParameterNullPassingEnabled = cfgService.getSetting( PROCEDURE_NULL_PARAM_PASSING, BOOLEAN, false );
 		this.collectionJoinSubqueryRewriteEnabled = cfgService.getSetting( COLLECTION_JOIN_SUBQUERY, BOOLEAN, true );
+		this.omitJoinOfSuperclassTablesEnabled = cfgService.getSetting( OMIT_JOIN_OF_SUPERCLASS_TABLES, BOOLEAN, true );
 
 		final RegionFactory regionFactory = serviceRegistry.getService( RegionFactory.class );
 		if ( !NoCachingRegionFactory.class.isInstance( regionFactory ) ) {
@@ -1064,6 +1067,12 @@ public boolean isEnhancementAsProxyEnabled() {
 		return enhancementAsProxyEnabled;
 	}
 
+	@Override
+	public boolean isOmitJoinOfSuperclassTablesEnabled() {
+		return omitJoinOfSuperclassTablesEnabled;
+	}
+
+
 	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 	// In-flight mutation access
 

hibernate-core/src/main/java/org/hibernate/boot/registry/classloading/internal/AggregatedServiceLoader.java

@@ -15,19 +15,24 @@
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.ServiceConfigurationError;
 import java.util.ServiceLoader;
 import java.util.Set;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 
 import org.hibernate.AssertionFailure;
+import org.hibernate.internal.CoreLogging;
+import org.hibernate.internal.CoreMessageLogger;
 
 /**
  * A service loader bound to an {@link AggregatedClassLoader}.
  * @param <S> The type of the service contract.
  */
 abstract class AggregatedServiceLoader<S> {
 
+	private static final CoreMessageLogger log = CoreLogging.messageLogger( AggregatedServiceLoader.class );
+
 	private static final Method SERVICE_LOADER_STREAM_METHOD;
 	private static final Method PROVIDER_TYPE_METHOD;
 
@@ -145,17 +150,16 @@ public void close() {
 	 * @param <S> The type of loaded services.
 	 */
 	private static class ClassPathAndModulePathAggregatedServiceLoader<S> extends AggregatedServiceLoader<S> {
+		private final Class<S> serviceContract;
+		private final ServiceLoader<S> aggregatedClassLoaderServiceLoader;
 		private final List<ServiceLoader<S>> delegates;
 		private Collection<S> cache = null;
 
 		private ClassPathAndModulePathAggregatedServiceLoader(AggregatedClassLoader aggregatedClassLoader,
 				Class<S> serviceContract) {
+			this.serviceContract = serviceContract;
 			this.delegates = new ArrayList<>();
-			// Always try the aggregated class loader first
-			this.delegates.add( ServiceLoader.load( serviceContract, aggregatedClassLoader ) );
-
-			// Then also try the individual class loaders,
-			// because only them can instantiate services provided by jars in the module path
+			this.aggregatedClassLoaderServiceLoader = ServiceLoader.load( serviceContract, aggregatedClassLoader );
 			final Iterator<ClassLoader> clIterator = aggregatedClassLoader.newClassLoaderIterator();
 			while ( clIterator.hasNext() ) {
 				this.delegates.add(
@@ -185,54 +189,94 @@ public Collection<S> getAll() {
 			return cache;
 		}
 
-		@SuppressWarnings("unchecked")
 		private Collection<S> loadAll() {
 			Set<String> alreadyEncountered = new HashSet<>();
 			Set<S> result = new LinkedHashSet<>();
-			delegates.stream()
-					// Each loader's stream() method returns a stream of service providers: flatten these into a single stream
-					.flatMap( delegate -> {
-						try {
-							return (Stream<? extends Supplier<S>>) SERVICE_LOADER_STREAM_METHOD.invoke( delegate );
-						}
-						catch (RuntimeException | IllegalAccessException | InvocationTargetException e) {
-							throw new AssertionFailure( "Error calling ServiceLoader.stream()", e );
-						}
-					} )
-					// For each provider, check its type to be sure we don't use a provider twice, then get the service
-					.forEach( provider -> {
-						Class<?> type;
-						try {
-							type = (Class<?>) PROVIDER_TYPE_METHOD.invoke( provider );
-						}
-						catch (RuntimeException | IllegalAccessException | InvocationTargetException e) {
-							throw new AssertionFailure( "Error calling ServiceLoader.Provider.type()", e );
-						}
-						String typeName = type.getName();
-						/*
-						 * We may encounter the same service provider multiple times,
-						 * because the individual class loaders may give access to the same types
-						 * (at the very least a single class loader may be present twice in the aggregated class loader).
-						 * However, we only want to get the service from each provider once.
-						 *
-						 * ServiceLoader.stream() is useful in that regard,
-						 * since it allows us to check the type of the service provider
-						 * before the service is even instantiated.
-						 *
-						 * We could just instantiate every service and check their type afterwards,
-						 * but 1. it would lead to unnecessary instantiation which could have side effects,
-						 * in particular regarding class loading,
-						 * and 2. the type of the provider may not always be the type of the service,
-						 * and one provider may return different types of services
-						 * depending on conditions known only to itself.
-						 */
-						if ( alreadyEncountered.add( typeName ) ) {
-							result.add( provider.get() );
-						}
-					} );
+
+			// Always try the aggregated class loader first
+			Iterator<? extends Supplier<S>> providerIterator = providerStream( aggregatedClassLoaderServiceLoader )
+					.iterator();
+			while ( providerIterator.hasNext() ) {
+				Supplier<S> provider = providerIterator.next();
+				collectServiceIfNotDuplicate( result, alreadyEncountered, provider );
+			}
+
+			/*
+			 * Then also try the individual class loaders,
+			 * because only them can instantiate services provided by jars in the module path.
+			 */
+			for ( ServiceLoader<S> delegate : delegates ) {
+				providerIterator = providerStream( delegate ).iterator();
+				/*
+				 * Note that advancing the stream itself can lead to (arguably) "legitimate" errors,
+				 * where we fail to load the service,
+				 * but only because individual classloader has its own definition of the service contract class,
+				 * which is different from ours.
+				 * In that case (still arguably), the error should be ignored.
+				 * That's why we wrap the call to hasNext in a method that catches an logs errors.
+				 * See https://hibernate.atlassian.net/browse/HHH-13551.
+				 */
+				while ( hasNextIgnoringServiceConfigurationError( providerIterator ) ) {
+					Supplier<S> provider = providerIterator.next();
+					collectServiceIfNotDuplicate( result, alreadyEncountered, provider );
+				}
+			}
+
 			return result;
 		}
 
+		@SuppressWarnings("unchecked")
+		private Stream<? extends Supplier<S>> providerStream(ServiceLoader<S> serviceLoader) {
+			try {
+				return ( (Stream<? extends Supplier<S>>) SERVICE_LOADER_STREAM_METHOD.invoke( serviceLoader ) );
+			}
+			catch (RuntimeException | IllegalAccessException | InvocationTargetException e) {
+				throw new AssertionFailure( "Error calling ServiceLoader.stream()", e );
+			}
+		}
+
+		private boolean hasNextIgnoringServiceConfigurationError(Iterator<?> iterator) {
+			while ( true ) {
+				try {
+					return iterator.hasNext();
+				}
+				catch (ServiceConfigurationError e) {
+					log.ignoringServiceConfigurationError( serviceContract, e );
+				}
+			}
+		}
+
+		/*
+		 * We may encounter the same service provider multiple times,
+		 * because the individual class loaders may give access to the same types
+		 * (at the very least a single class loader may be present twice in the aggregated class loader).
+		 * However, we only want to get the service from each provider once.
+		 *
+		 * ServiceLoader.stream() is useful in that regard,
+		 * since it allows us to check the type of the service provider
+		 * before the service is even instantiated.
+		 *
+		 * We could just instantiate every service and check their type afterwards,
+		 * but 1. it would lead to unnecessary instantiation which could have side effects,
+		 * in particular regarding class loading,
+		 * and 2. the type of the provider may not always be the type of the service,
+		 * and one provider may return different types of services
+		 * depending on conditions known only to itself.
+		 */
+		private void collectServiceIfNotDuplicate(Set<S> result, Set<String> alreadyEncountered, Supplier<S> provider) {
+			Class<?> type;
+			try {
+				type = (Class<?>) PROVIDER_TYPE_METHOD.invoke( provider );
+			}
+			catch (RuntimeException | IllegalAccessException | InvocationTargetException e) {
+				throw new AssertionFailure( "Error calling ServiceLoader.Provider.type()", e );
+			}
+			String typeName = type.getName();
+			if ( alreadyEncountered.add( typeName ) ) {
+				result.add( provider.get() );
+			}
+		}
+
 		@Override
 		public void close() {
 			cache = null;

hibernate-core/src/main/java/org/hibernate/boot/spi/AbstractDelegatingSessionFactoryOptions.java

@@ -447,4 +447,9 @@ public boolean areJPACallbacksEnabled() {
 	public boolean isEnhancementAsProxyEnabled() {
 		return delegate.isEnhancementAsProxyEnabled();
 	}
+
+	@Override
+	public boolean isOmitJoinOfSuperclassTablesEnabled() {
+		return delegate.isOmitJoinOfSuperclassTablesEnabled();
+	}
 }

hibernate-core/src/main/java/org/hibernate/boot/spi/SessionFactoryOptions.java

@@ -314,4 +314,6 @@ default boolean areJPACallbacksEnabled() {
 	default boolean isEnhancementAsProxyEnabled() {
 		return false;
 	}
+
+	boolean isOmitJoinOfSuperclassTablesEnabled();
 }

hibernate-core/src/main/java/org/hibernate/boot/spi/XmlMappingBinderAccess.java

@@ -83,13 +83,13 @@ public Binding bind(InputStreamAccess xmlInputStreamAccess) {
 				xmlInputStream.close();
 			}
 			catch (IOException e) {
-				LOG.debugf( "Unable to close InputStream obtained from InputStreamAccess : " + xmlInputStreamAccess.getStreamName() );
+				LOG.debugf( "Unable to close InputStream obtained from InputStreamAccess : %s", xmlInputStreamAccess.getStreamName() );
 			}
 		}
 	}
 
 	public Binding bind(InputStream xmlInputStream) {
-		LOG.tracef( "reading mappings from InputStream" );
+		LOG.trace( "reading mappings from InputStream" );
 		final Origin origin = new Origin( SourceType.INPUT_STREAM, null );
 		return new InputStreamXmlSource( origin, xmlInputStream, false ).doBind( getMappingBinder() );
 	}