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

Author: theigl

docker_db.sh

@@ -655,7 +655,7 @@ sinks:
     redact: false
     exit-on-error: true
 "
-  $CONTAINER_CLI run -d --name=cockroach -m 3g -p 26257:26257 -p 8080:8080 docker.io/cockroachdb/cockroach:v22.2.2 start-single-node \
+  $CONTAINER_CLI run -d --name=cockroach -m 6g -p 26257:26257 -p 8080:8080 docker.io/cockroachdb/cockroach:v22.2.2 start-single-node \
     --insecure --store=type=mem,size=0.25 --advertise-addr=localhost --log="$LOG_CONFIG"
   OUTPUT=
   while [[ $OUTPUT != *"CockroachDB node starting"* ]]; do
@@ -695,7 +695,7 @@ sinks:
     redact: false
     exit-on-error: true
 "
-  $CONTAINER_CLI run -d --name=cockroach -m 3g -p 26257:26257 -p 8080:8080 docker.io/cockroachdb/cockroach:v22.1.13 start-single-node \
+  $CONTAINER_CLI run -d --name=cockroach -m 6g -p 26257:26257 -p 8080:8080 docker.io/cockroachdb/cockroach:v22.1.13 start-single-node \
     --insecure --store=type=mem,size=0.25 --advertise-addr=localhost --log="$LOG_CONFIG"
   OUTPUT=
   while [[ $OUTPUT != *"CockroachDB node starting"* ]]; do
@@ -735,7 +735,7 @@ sinks:
     redact: false
     exit-on-error: true
 "
-  $CONTAINER_CLI run -d --name=cockroach -m 3g -p 26257:26257 -p 8080:8080 docker.io/cockroachdb/cockroach:v21.2.16 start-single-node \
+  $CONTAINER_CLI run -d --name=cockroach -m 6g -p 26257:26257 -p 8080:8080 docker.io/cockroachdb/cockroach:v21.2.16 start-single-node \
     --insecure --store=type=mem,size=640MiB --advertise-addr=localhost --log="$LOG_CONFIG"
   OUTPUT=
   while [[ $OUTPUT != *"CockroachDB node starting"* ]]; do

hibernate-core/src/main/java/org/hibernate/Cache.java

@@ -16,7 +16,8 @@
  *     {@link Session}.
  * <li>The <em>second-level cache</em> is shared between all sessions belonging to
  *     a given {@link SessionFactory}. It stores the state of an entity instance
- *     in a destructured format, as a tuple of persistent attribute values.
+ *     in a destructured format, as a tuple of persistent attribute values. The
+ *     second-level cache is also used to store cached query result sets.
  * </ul>
  * <p>
  * By nature, a second-level cache tends to undermine the ACID properties of
@@ -82,6 +83,19 @@
  * account the expected patterns of data access, most importantly, the frequency
  * of updates.
  * <p>
+ * Query result sets may also be stored in the second-level cache. A query is made
+ * eligible for caching by calling
+ * {@link org.hibernate.query.SelectionQuery#setCacheable(boolean)}, and may be
+ * assigned to a region of the second-level cache by calling
+ * {@link org.hibernate.query.SelectionQuery#setCacheRegion(String)}. It's very
+ * important to understand that any entity instance in a query result set is cached
+ * by its id. If the entity itself is not {@linkplain org.hibernate.annotations.Cache
+ * cacheable}, or if the instance is not available in the second-level cache at the
+ * time a result set is retrieved from the cache, then the state of the entity must
+ * be read from the database. <em>This negates the benefits of caching the result
+ * set.</em> It's therefore very important to carefully "match" the caching policies
+ * of a query and the entities it returns.
+ * <p>
  * Hibernate does not itself contain a high-quality implementation of a second-level
  * cache backend with expiry, persistence, and replication, and depends on a plug-in
  * implementation of {@link org.hibernate.cache.spi.RegionFactory} to integrate a

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

@@ -9,23 +9,28 @@
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
 
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
 import static java.lang.annotation.ElementType.TYPE;
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
- * Specifies the tables that hold state mapped by the annotated entity.
+ * Specifies a table or tables that hold state mapped by the annotated
+ * entity or collection.
  * <p>
  * 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.
+ * by an entity class or collection, then modifications might not be
+ * {@linkplain org.hibernate.FlushMode#AUTO automatically synchronized}
+ * with the database before a query is executed against that table, and
+ * the query might return stale data.
  * <p>
- * This annotation might be necessary if:
+ * Ordinarily, Hibernate knows the tables containing the state of an
+ * entity or collection. 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}.
+ * <li>an entity or collection maps a database view,
+ * <li>an entity or collection is persisted using handwritten SQL,
+ *     that is, using {@link SQLSelect @SQLSelect} and friends, or
+ * <li>an entity is mapped using {@link Subselect @Subselect}.
  * </ul>
  * <p>
  * By default, the table names specified by this annotation are interpreted
@@ -39,7 +44,7 @@
  *
  * @see org.hibernate.query.SynchronizeableQuery
  */
-@Target(TYPE)
+@Target({TYPE, FIELD, METHOD})
 @Retention(RUNTIME)
 public @interface Synchronize {
 	/**

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

@@ -22,8 +22,6 @@
 import java.util.function.Consumer;
 import java.util.stream.Stream;
 
-import jakarta.persistence.Embeddable;
-import jakarta.persistence.EmbeddedId;
 import org.hibernate.AnnotationException;
 import org.hibernate.AssertionFailure;
 import org.hibernate.FetchMode;
@@ -45,11 +43,13 @@
 import org.hibernate.dialect.DatabaseVersion;
 import org.hibernate.dialect.Dialect;
 import org.hibernate.mapping.Any;
+import org.hibernate.mapping.AttributeContainer;
 import org.hibernate.mapping.BasicValue;
 import org.hibernate.mapping.Collection;
 import org.hibernate.mapping.Column;
 import org.hibernate.mapping.Component;
 import org.hibernate.mapping.Join;
+import org.hibernate.mapping.JoinedSubclass;
 import org.hibernate.mapping.MappedSuperclass;
 import org.hibernate.mapping.PersistentClass;
 import org.hibernate.mapping.Property;
@@ -60,6 +60,8 @@
 import org.hibernate.mapping.Value;
 import org.hibernate.type.descriptor.java.JavaType;
 
+import jakarta.persistence.Embeddable;
+import jakarta.persistence.EmbeddedId;
 import jakarta.persistence.FetchType;
 import jakarta.persistence.ManyToOne;
 import jakarta.persistence.OneToOne;
@@ -145,7 +147,7 @@ public static void createSyntheticPropertyReference(
 			// figure out which table has the columns by looking
 			// for a PersistentClass or Join in the hierarchy of
 			// the target entity which has the first column
-			final Object columnOwner = findReferencedColumnOwner( targetEntity, joinColumns.getJoinColumns().get(0), context );
+			final AttributeContainer columnOwner = findReferencedColumnOwner( targetEntity, joinColumns.getJoinColumns().get(0), context );
 			checkColumnInSameTable( joinColumns, targetEntity, associatedEntity, context, columnOwner );
 			// find all properties mapped to each column
 			final List<Property> properties = findPropertiesByColumns( columnOwner, joinColumns, associatedEntity, context );
@@ -224,7 +226,7 @@ private static Property referencedProperty(
 			PersistentClass associatedEntity,
 			String propertyName,
 			boolean inverse,
-			Object columnOwner,
+			AttributeContainer columnOwner,
 			List<Property> properties,
 			MetadataBuildingContext context) {
 		if ( properties.size() == 1
@@ -314,7 +316,7 @@ else if ( joinColumns.getPropertyHolder() != null ) {
 	 */
 	private static Property makeSyntheticComponentProperty(
 			PersistentClass ownerEntity,
-			Object persistentClassOrJoin,
+			AttributeContainer persistentClassOrJoin,
 			MetadataBuildingContext context,
 			String syntheticPropertyName,
 			List<Property> properties) {
@@ -334,7 +336,13 @@ private static Property makeSyntheticComponentProperty(
 		result.setInsertable( false );
 		result.setValue( embeddedComponent );
 		result.setPropertyAccessorName( "embedded" );
-		ownerEntity.addProperty( result );
+		if ( persistentClassOrJoin instanceof Join ) {
+			// the referenced column is in the joined table, add the synthetic property there
+			persistentClassOrJoin.addProperty( result );
+		}
+		else {
+			ownerEntity.addProperty( result );
+		}
 		embeddedComponent.createUniqueKey(); //make it unique
 		return result;
 	}
@@ -683,7 +691,7 @@ public static String getRelativePath(PropertyHolder propertyHolder, String prope
 		}
 	}
 
-	public static Object findReferencedColumnOwner(
+	public static AttributeContainer findReferencedColumnOwner(
 			PersistentClass persistentClass,
 			AnnotatedJoinColumn joinColumn,
 			MetadataBuildingContext context) {
@@ -696,7 +704,7 @@ public static Object findReferencedColumnOwner(
 	 * Find the column owner (ie PersistentClass or Join) of columnName.
 	 * If columnName is null or empty, persistentClass is returned
 	 */
-	public static Object findColumnOwner(
+	public static AttributeContainer findColumnOwner(
 			PersistentClass persistentClass,
 			String columnName,
 			MetadataBuildingContext context) {

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

@@ -68,6 +68,7 @@
 import org.hibernate.annotations.SQLUpdate;
 import org.hibernate.annotations.SortComparator;
 import org.hibernate.annotations.SortNatural;
+import org.hibernate.annotations.Synchronize;
 import org.hibernate.annotations.Where;
 import org.hibernate.annotations.WhereJoinTable;
 import org.hibernate.annotations.common.reflection.ReflectionManager;
@@ -83,6 +84,7 @@
 import org.hibernate.boot.spi.PropertyData;
 import org.hibernate.boot.spi.SecondPass;
 import org.hibernate.engine.config.spi.ConfigurationService;
+import org.hibernate.engine.jdbc.env.spi.JdbcEnvironment;
 import org.hibernate.engine.spi.FilterDefinition;
 import org.hibernate.internal.CoreMessageLogger;
 import org.hibernate.internal.util.collections.CollectionHelper;
@@ -1642,6 +1644,7 @@ protected void bindOneToManySecondPass(Map<String, PersistentClass> persistentCl
 			LOG.debugf( "Mapping collection: %s -> %s", collection.getRole(), collection.getCollectionTable().getName() );
 		}
 
+		bindSynchronize();
 		bindFilters( false );
 		handleWhere( false );
 
@@ -1681,6 +1684,26 @@ private void handleJpaOrderBy(Collection collection, PersistentClass associatedC
 		}
 	}
 
+	private void bindSynchronize() {
+		if ( property.isAnnotationPresent( Synchronize.class ) ) {
+			final JdbcEnvironment jdbcEnvironment = buildingContext.getMetadataCollector().getDatabase().getJdbcEnvironment();
+			final Synchronize synchronize = property.getAnnotation(Synchronize.class);
+			for ( String table : synchronize.value() ) {
+				String physicalName = synchronize.logical() ? toPhysicalName( jdbcEnvironment, table ) : table;
+				collection.addSynchronizedTable( physicalName );
+			}
+		}
+	}
+
+	private String toPhysicalName(JdbcEnvironment jdbcEnvironment, String logicalName) {
+		return buildingContext.getBuildingOptions().getPhysicalNamingStrategy()
+				.toPhysicalTableName(
+						jdbcEnvironment.getIdentifierHelper().toIdentifier( logicalName ),
+						jdbcEnvironment
+				)
+				.render( jdbcEnvironment.getDialect() );
+	}
+
 	private void bindFilters(boolean hasAssociationTable) {
 		final Filter simpleFilter = property.getAnnotation( Filter.class );
 		//set filtering
@@ -2084,6 +2107,8 @@ private void bindManyToManySecondPass(Map<String, PersistentClass> persistentCla
 		else {
 			handleOwnedManyToMany( targetEntity, isCollectionOfEntities );
 		}
+
+		bindSynchronize();
 		bindFilters( isCollectionOfEntities );
 		handleWhere( isCollectionOfEntities );
 

hibernate-core/src/main/java/org/hibernate/cache/internal/BasicCacheKeyImplementation.java

@@ -0,0 +1,91 @@
+/*
+ * 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 <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ */
+package org.hibernate.cache.internal;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+import org.hibernate.Internal;
+import org.hibernate.engine.spi.SessionFactoryImplementor;
+import org.hibernate.type.Type;
+
+/**
+ * Key produced by DefaultCacheKeysFactory; this is the specialized implementation
+ * for the case in which the disassembled identifier is not an array and the tenantId
+ * is not being defined.
+ * The goal of this specialized representation is to be more efficient for this most common
+ * scenario, and save memory by omitting some fields.
+ * When making changes to this class, please be aware of its memory footprint.
+ *
+ * @author Sanne Grinovero
+ * @since 6.2
+ */
+@Internal
+final class BasicCacheKeyImplementation implements Serializable {
+
+	final Serializable id;
+	private final String entityOrRoleName;
+	private final int hashCode;
+
+	/**
+	 * Being an internal contract the arguments are not being checked.
+	 * @param originalId
+	 * @param disassembledKey this must be the "disassembled" form of an ID
+	 * @param type
+	 * @param entityOrRoleName
+	 */
+	@Internal
+	public BasicCacheKeyImplementation(
+			final Object originalId,
+			final Serializable disassembledKey,
+			final Type type,
+			final String entityOrRoleName) {
+		assert disassembledKey != null;
+		assert entityOrRoleName != null;
+		this.id = disassembledKey;
+		this.entityOrRoleName = entityOrRoleName;
+		this.hashCode = calculateHashCode( originalId, type );
+	}
+
+	private static int calculateHashCode(Object disassembledKey, Type type) {
+		return type.getHashCode( disassembledKey );
+	}
+
+	public Object getId() {
+		return id;
+	}
+
+	@Override
+	public boolean equals(final Object other) {
+		if ( other == null ) {
+			return false;
+		}
+		else if ( this == other ) {
+			return true;
+		}
+		else if ( other.getClass() != BasicCacheKeyImplementation.class ) {
+			return false;
+		}
+		else {
+			final BasicCacheKeyImplementation o = (BasicCacheKeyImplementation) other;
+			return this.id.equals( o.id ) &&
+					this.entityOrRoleName.equals( o.entityOrRoleName );
+		}
+	}
+
+	@Override
+	public int hashCode() {
+		return hashCode;
+	}
+
+	@Override
+	public String toString() {
+		// Used to be required for OSCache
+		return entityOrRoleName + '#' + id.toString();
+	}
+
+}