Merge remote-tracking branch 'upstream/main' into main-perf

Author: theigl

Jenkinsfile

@@ -44,12 +44,12 @@ stage('Configure') {
 				additionalOptions: '-DdbHost=localhost:4000',
 				notificationRecipients: '[email protected]' ),
 		new BuildEnvironment( testJdkVersion: '17' ),
-		new BuildEnvironment( testJdkVersion: '18' ),
-		// We want to enable preview features when testing early-access builds of OpenJDK:
+		// We want to enable preview features when testing newer builds of OpenJDK:
 		// even if we don't use these features, just enabling them can cause side effects
 		// and it's useful to test that.
 		new BuildEnvironment( testJdkVersion: '19', testJdkLauncherArgs: '--enable-preview' ),
-		new BuildEnvironment( testJdkVersion: '20', testJdkLauncherArgs: '--enable-preview' )
+		new BuildEnvironment( testJdkVersion: '20', testJdkLauncherArgs: '--enable-preview' ),
+		new BuildEnvironment( testJdkVersion: '21', testJdkLauncherArgs: '--enable-preview' )
 	];
 
 	if ( env.CHANGE_ID ) {

hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/MySQLLegacySqlAstTranslator.java

@@ -240,7 +240,7 @@ protected String getFromDual() {
 
 	@Override
 	protected String getFromDualForSelectOnly() {
-		return getDialect().getVersion().isBefore( 5, 7 ) ? getFromDual() : "";
+		return getDialect().getVersion().isSameOrAfter( 8 ) ? "" : getFromDual();
 	}
 
 	@Override

hibernate-core/src/main/java/org/hibernate/annotations/NamedNativeQuery.java

@@ -156,10 +156,14 @@
 	boolean readOnly() default false;
 
 	/**
-	 * The query spaces involved in this query.
+	 * The {@linkplain org.hibernate.query.SynchronizeableQuery query spaces}
+	 * involved in this query.
+	 * <p>
+	 * Typically, the names of tables which are referenced by the query.
 	 *
-	 * @see org.hibernate.query.SynchronizeableQuery
+	 * @see org.hibernate.query.SynchronizeableQuery#addSynchronizedQuerySpace
 	 * @see org.hibernate.jpa.HibernateHints#HINT_NATIVE_SPACES
+	 * @see Synchronize
 	 */
 	String[] querySpaces() default {};
 

hibernate-core/src/main/java/org/hibernate/annotations/NamedQuery.java

@@ -86,7 +86,7 @@
 	 *
 	 * @see org.hibernate.query.CommonQueryContract#setTimeout(int)
 	 * @see org.hibernate.jpa.HibernateHints#HINT_TIMEOUT
-	 * @see import org.hibernate.jpa.SpecHints#HINT_SPEC_QUERY_TIMEOUT
+	 * @see org.hibernate.jpa.SpecHints#HINT_SPEC_QUERY_TIMEOUT
 	 */
 	int timeout() default -1;
 

hibernate-core/src/main/java/org/hibernate/annotations/Synchronize.java

@@ -13,22 +13,47 @@
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
- * Specifies the tables that hold state mapped by the annotated derived
- * entity, ensuring that auto-flush happens correctly and that queries
- * against the derived entity do not return stale data.
+ * Specifies the tables that hold state mapped by the annotated entity.
  * <p>
- * This annotation may be used in combination with {@link Subselect}, or
- * when an entity maps a database view.
- * 
+ * If Hibernate is not aware that a certain table holds state mapped
+ * by an entity class, then {@linkplain org.hibernate.FlushMode#AUTO
+ * auto-flush} might not occur when it should, and queries against the
+ * entity might return stale data.
+ * <p>
+ * This annotation might be necessary if:
+ * <ul>
+ * <li>the entity maps a database view,
+ * <li>the entity is persisted using handwritten SQL, that is, using
+ *     {@link SQLSelect @SQLSelect} and friends, or
+ * <li>the entity is mapped using {@link Subselect @Subselect}.
+ * </ul>
+ * <p>
+ * By default, the table names specified by this annotation are interpreted
+ * as {@linkplain org.hibernate.boot.model.naming.PhysicalNamingStrategy
+ * logical names}, and are processed by
+ * {@link org.hibernate.boot.model.naming.PhysicalNamingStrategy#toPhysicalTableName}.
+ * But if {@link #logical logical=false}, the table names will be treated
+ * as physical names, and will not be processed by the naming strategy.
+ *
  * @author Sharath Reddy
+ *
+ * @see org.hibernate.query.SynchronizeableQuery
  */
 @Target(TYPE)
 @Retention(RUNTIME)
 public @interface Synchronize {
 	/**
-	 * Names of tables that hold state mapped by the derived entity.
+	 * Names of tables that hold state mapped by the annotated entity.
 	 * Updates to these tables must be flushed to the database before
-	 * the derived entity is queried.
+	 * execution of any query which refers to the annotated entity.
 	 */
 	String[] value();
+
+	/**
+	 * Specifies whether the table names given by {@link #value}
+	 * should be interpreted as logical or physical names.
+	 *
+	 * @return {@code true} if they are logical names
+	 */
+	boolean logical() default true;
 }

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

@@ -144,20 +144,19 @@ public MetadataBuilderImpl(MetadataSources sources, StandardServiceRegistry serv
 		//		these should be set during the StandardServiceRegistryBuilder.configure call
 		applyCfgXmlValues( serviceRegistry.getService( CfgXmlAccessService.class ) );
 
-		final ClassLoaderService classLoaderService = serviceRegistry.getService( ClassLoaderService.class );
-		for ( MetadataBuilderInitializer contributor : classLoaderService.loadJavaServices( MetadataBuilderInitializer.class ) ) {
+		for ( MetadataBuilderInitializer contributor :
+				serviceRegistry.getService( ClassLoaderService.class )
+						.loadJavaServices( MetadataBuilderInitializer.class ) ) {
 			contributor.contribute( this, serviceRegistry );
 		}
 	}
 
 	private void applyCfgXmlValues(CfgXmlAccessService service) {
 		final LoadedConfig aggregatedConfig = service.getAggregatedConfig();
-		if ( aggregatedConfig == null ) {
-			return;
-		}
-
-		for ( CacheRegionDefinition cacheRegionDefinition : aggregatedConfig.getCacheRegionDefinitions() ) {
-			applyCacheRegionDefinition( cacheRegionDefinition );
+		if ( aggregatedConfig != null ) {
+			for ( CacheRegionDefinition cacheRegionDefinition : aggregatedConfig.getCacheRegionDefinitions() ) {
+				applyCacheRegionDefinition( cacheRegionDefinition );
+			}
 		}
 	}
 

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

@@ -15,7 +15,7 @@
 import org.hibernate.boot.spi.MetadataBuildingOptions;
 
 /**
- * Root MetadataBuildingContext
+ * Root {@link MetadataBuildingContext}.
  */
 public class MetadataBuildingContextRootImpl implements MetadataBuildingContext {
 	private final String contributor;

hibernate-core/src/main/java/org/hibernate/boot/model/FunctionContributions.java

@@ -6,6 +6,7 @@
  */
 package org.hibernate.boot.model;
 
+import org.hibernate.dialect.Dialect;
 import org.hibernate.query.sqm.function.SqmFunctionRegistry;
 import org.hibernate.service.Service;
 import org.hibernate.service.ServiceRegistry;
@@ -28,12 +29,19 @@ public interface FunctionContributions {
 	SqmFunctionRegistry getFunctionRegistry();
 
 	/**
-	 * Access to type information
+	 * Access to type information.
 	 */
 	TypeConfiguration getTypeConfiguration();
 
 	/**
-	 * Access to {@linkplain Service services}
+	 * Access to {@linkplain Service services}.
 	 */
 	ServiceRegistry getServiceRegistry();
+
+	/**
+	 * The {@linkplain Dialect SQL Dialect}.
+	 */
+	default Dialect getDialect() {
+		return getTypeConfiguration().getCurrentBaseSqlTypeIndicators().getDialect();
+	}
 }

hibernate-core/src/main/java/org/hibernate/boot/model/TypeContributor.java

@@ -21,6 +21,8 @@
  *     {@link org.hibernate.cfg.Configuration#registerTypeContributor(TypeContributor)}
  *     or even {@link org.hibernate.boot.MetadataBuilder#applyTypes(TypeContributor)}.
  * <li>
+ *     When bootstrapping Hibernate via JPA or {@link org.hibernate.cfg.Configuration},
+ *
  *     Finally, in the JPA boostrap process, {@code TypeContributor}s may be
  *     listed via {@link org.hibernate.jpa.boot.spi.JpaSettings#TYPE_CONTRIBUTORS}.
  * </ul>

hibernate-core/src/main/java/org/hibernate/boot/model/internal/AnnotatedJoinColumn.java

@@ -404,13 +404,14 @@ static AnnotatedJoinColumn buildImplicitJoinTableJoinColumn(
 			PropertyData inferredData) {
 		final AnnotatedJoinColumn column = new AnnotatedJoinColumn();
 		column.setImplicit( true );
-		column.setNullable( false ); //I break the spec, but it's for good
+
 //		column.setPropertyHolder( propertyHolder );
 //		column.setPropertyName( getRelativePath( propertyHolder, propertyName ) );
 //		column.setJoins( secondaryTables );
 //		column.setContext( context );
 		column.setParent( parent );
 		column.bind();
+		column.setNullable( false ); //I break the spec, but it's for good
 		return column;
 	}
 
@@ -425,11 +426,11 @@ static AnnotatedJoinColumn buildExplicitJoinTableJoinColumn(
 //		column.setPropertyName( getRelativePath( propertyHolder, propertyName ) );
 //		column.setJoins( secondaryTables );
 //		column.setContext( context );
-		column.setNullable( false ); //I break the spec, but it's for good
 		//done after the annotation to override it
 		column.setParent( parent );
 		column.applyJoinAnnotation( joinColumn, inferredData.getPropertyName() );
 		column.bind();
+		column.setNullable( false ); //I break the spec, but it's for good
 		return column;
 	}
 

hibernate-core/src/main/java/org/hibernate/boot/model/internal/BinderHelper.java

@@ -125,8 +125,8 @@ public static boolean isPrimitive(String elementTypeName) {
 	 * property of an {@code @Embeddable}, then every column of that
 	 * embeddable must occur in the list of referenced columns, and the
 	 * order of the columns must line up! Some of these limitations
-	 * could be relaxed using by writing a better algorithm for building
-	 * the synthetic {@link Component}.
+	 * could be relaxed by writing a better algorithm for building the
+	 * synthetic {@link Component}.
 	 */
 	public static void createSyntheticPropertyReference(
 			AnnotatedJoinColumns joinColumns,

hibernate-core/src/main/java/org/hibernate/boot/model/internal/EntityBinder.java

@@ -1336,17 +1336,23 @@ private String getDefaultFilterCondition(String filterName) {
 	private void bindSynchronize() {
 		if ( annotatedClass.isAnnotationPresent( Synchronize.class ) ) {
 			final JdbcEnvironment jdbcEnvironment = context.getMetadataCollector().getDatabase().getJdbcEnvironment();
-			for ( String table : annotatedClass.getAnnotation(Synchronize.class).value() ) {
-				persistentClass.addSynchronizedTable(
-						context.getBuildingOptions().getPhysicalNamingStrategy().toPhysicalTableName(
-								jdbcEnvironment.getIdentifierHelper().toIdentifier( table ),
-								jdbcEnvironment
-						).render( jdbcEnvironment.getDialect() )
-				);
+			final Synchronize synchronize = annotatedClass.getAnnotation(Synchronize.class);
+			for ( String table : synchronize.value() ) {
+				String physicalName = synchronize.logical() ? toPhysicalName( jdbcEnvironment, table ) : table;
+				persistentClass.addSynchronizedTable( physicalName );
 			}
 		}
 	}
 
+	private String toPhysicalName(JdbcEnvironment jdbcEnvironment, String logicalName) {
+		return context.getBuildingOptions().getPhysicalNamingStrategy()
+				.toPhysicalTableName(
+						jdbcEnvironment.getIdentifierHelper().toIdentifier( logicalName ),
+						jdbcEnvironment
+				)
+				.render( jdbcEnvironment.getDialect() );
+	}
+
 	@SuppressWarnings({"rawtypes", "unchecked"})
 	private void bindCustomPersister() {
 		//set persister if needed