Merge branch 'hibernate:main' into HHH-18532

Author: cigaly

hibernate-core/src/main/java/org/hibernate/engine/internal/UnsavedValueFactory.java

@@ -21,6 +21,8 @@
 import org.hibernate.type.descriptor.java.VersionJavaType;
 import org.hibernate.type.descriptor.java.spi.PrimitiveJavaType;
 
+import static org.hibernate.engine.internal.Versioning.isNullInitialVersion;
+
 /**
  * Helper for dealing with unsaved value handling
  *
@@ -81,25 +83,20 @@ else if ( idJtd instanceof PrimitiveJavaType ) {
 	public static <T> VersionValue getUnsavedVersionValue(
 			KeyValue bootVersionMapping,
 			VersionJavaType<T> jtd,
-			Long length,
-			Integer precision,
-			Integer scale,
 			Getter getter,
-			Supplier<?> templateInstanceAccess,
-			SessionFactoryImplementor sessionFactory) {
+			Supplier<?> templateInstanceAccess) {
 		final String unsavedValue = bootVersionMapping.getNullValue();
 		if ( unsavedValue == null ) {
 			if ( getter != null && templateInstanceAccess != null ) {
-				Object templateInstance = templateInstanceAccess.get();
+				final Object templateInstance = templateInstanceAccess.get();
 				@SuppressWarnings("unchecked")
 				final T defaultValue = (T) getter.get( templateInstance );
-
-				// if the version of a newly instantiated object is not the same
-				// as the version seed value, use that as the unsaved-value
-				final T seedValue = jtd.seed( length, precision, scale, mockSession( sessionFactory ) );
-				return jtd.areEqual( seedValue, defaultValue )
-						? VersionValue.UNDEFINED
-						: new VersionValue( defaultValue );
+				// if the version of a newly instantiated object is null
+				// or a negative number, use that value as the unsaved-value,
+				// otherwise assume it's the initial version set by program
+				return isNullInitialVersion( defaultValue )
+						? new VersionValue( defaultValue )
+						: VersionValue.UNDEFINED;
 			}
 			else {
 				return VersionValue.UNDEFINED;

hibernate-core/src/main/java/org/hibernate/engine/internal/Versioning.java

@@ -6,7 +6,6 @@
  */
 package org.hibernate.engine.internal;
 
-import org.hibernate.Remove;
 import org.hibernate.engine.spi.SharedSessionContractImplementor;
 import org.hibernate.internal.CoreMessageLogger;
 import org.hibernate.metamodel.mapping.EntityVersionMapping;
@@ -86,44 +85,13 @@ public static boolean seedVersion(
 		}
 	}
 
-	/**
-	 * Create an initial optimistic locking value according the {@link VersionJavaType}
-	 * contract for the version property <em>if required</em> and inject it into the
-	 * snapshot state.
-	 *
-	 * @param fields The current snapshot state
-	 * @param versionProperty The index of the version property
-	 * @param versionMapping The version mapping
-	 * @param session The originating session
-	 * @return True if we injected a new version value into the fields array; false
-	 * otherwise.
-	 *
-	 * @deprecated Use {@link #seedVersion(Object, Object[], EntityPersister, SharedSessionContractImplementor)}
-	 */
-	@Deprecated(since = "6.2") @Remove
-	public static boolean seedVersion(
-			Object[] fields,
-			int versionProperty,
-			EntityVersionMapping versionMapping,
-			SharedSessionContractImplementor session) {
-		final Object initialVersion = fields[versionProperty];
-		if ( isNullInitialVersion( initialVersion ) ) {
-			fields[versionProperty] = seed( versionMapping, session );
-			return true;
-		}
-		else {
-			LOG.tracev( "Using initial version: {0}", initialVersion );
-			return false;
-		}
-	}
-
 	/**
 	 * Determines if the value of the assigned  version property should be considered
 	 * a "null" value, that is, if it is literally {@code null}, or if it is a negative
 	 * integer.
 	 *
 	 * @param initialVersion The value initially assigned to a version property
-	 * @return {@code} if the value shoudl be considered null for this purpose
+	 * @return {@code} if the value should be considered null for this purpose
 	 */
 	public static boolean isNullInitialVersion(Object initialVersion) {
 		return initialVersion == null

hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/EntityVersionMappingImpl.java

@@ -54,7 +54,7 @@ public class EntityVersionMappingImpl implements EntityVersionMapping, FetchOpti
 	private final Integer scale;
 	private final Integer temporalPrecision;
 
-	private final BasicType versionBasicType;
+	private final BasicType<?> versionBasicType;
 
 	private final VersionValue unsavedValueStrategy;
 
@@ -90,15 +90,10 @@ public EntityVersionMappingImpl(
 		unsavedValueStrategy = UnsavedValueFactory.getUnsavedVersionValue(
 				(KeyValue) bootEntityDescriptor.getVersion().getValue(),
 				(VersionJavaType<?>) versionBasicType.getJavaTypeDescriptor(),
-				length,
-				precision,
-				scale,
-				declaringType
-						.getRepresentationStrategy()
+				declaringType.getRepresentationStrategy()
 						.resolvePropertyAccess( bootEntityDescriptor.getVersion() )
 						.getGetter(),
-				templateInstanceAccess,
-				creationProcess.getCreationContext().getSessionFactory()
+				templateInstanceAccess
 		);
 	}
 

hibernate-core/src/main/java/org/hibernate/sql/exec/internal/VersionTypeSeedParameterSpecification.java

@@ -10,10 +10,8 @@
 import java.sql.SQLException;
 
 import org.hibernate.metamodel.mapping.EntityVersionMapping;
-import org.hibernate.metamodel.mapping.JdbcMapping;
 import org.hibernate.sql.exec.spi.ExecutionContext;
 import org.hibernate.sql.exec.spi.JdbcParameterBindings;
-import org.hibernate.type.descriptor.java.VersionJavaType;
 
 /**
  * Parameter bind specification used for optimistic lock version seeding (from insert statements).

hibernate-core/src/main/java/org/hibernate/type/descriptor/java/VersionJavaType.java

@@ -16,6 +16,10 @@
 public interface VersionJavaType<T> extends JavaType<T> {
 	/**
 	 * Generate an initial version.
+	 * <p>
+	 * Note that this operation is only used when the program sets a null or negative
+	 * number as the value of the entity version field. It is not called when the
+	 * program sets the version field to a sensible-looking version.
 	 *
 	 * @param length The length of the type
 	 * @param precision The precision of the type

hibernate-core/src/test/java/org/hibernate/orm/test/ops/MergeExplicitInitialVersionTest.java

@@ -0,0 +1,71 @@
+package org.hibernate.orm.test.ops;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.Id;
+import jakarta.persistence.Version;
+import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
+import org.hibernate.testing.orm.junit.Jpa;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@Jpa(annotatedClasses = {MergeExplicitInitialVersionTest.E.class,
+        MergeExplicitInitialVersionTest.F.class,
+        MergeExplicitInitialVersionTest.G.class})
+public class MergeExplicitInitialVersionTest {
+    @Test public void testGeneratedId(EntityManagerFactoryScope scope) {
+        E e = new E();
+        scope.inTransaction(s->s.persist(e));
+        assertEquals(e.version, 1);
+        e.text = "hello";
+        E e2 = scope.fromTransaction(s->s.merge(e));
+        assertEquals(e2.version, 2);
+    }
+    @Test public void testAssignedId(EntityManagerFactoryScope scope) {
+        F f = new F();
+        scope.inTransaction(s->s.persist(f));
+        assertEquals(f.version, 1);
+        f.text = "hello";
+        F f2 = scope.fromTransaction(s->s.merge(f));
+        assertEquals(f2.version, 2);
+    }
+    @Test public void testNegativeVersion(EntityManagerFactoryScope scope) {
+        G g = new G();
+        scope.inTransaction(s->s.persist(g));
+        assertEquals(g.version, 0);
+        g.text = "hello";
+        G g2 = scope.fromTransaction(s->s.merge(g));
+        assertEquals(g2.version, 1);
+    }
+
+    @Entity
+    static class E {
+        @Id
+        @GeneratedValue
+        long id;
+        @Version
+        int version = 1;
+        String text;
+    }
+
+    @Entity
+    static class F {
+        @Id
+        long id = 5;
+        @Version
+        int version = 1;
+        String text;
+    }
+
+    @Entity
+    static class G {
+        @Id
+        @GeneratedValue
+        long id;
+        @Version
+        int version = -1;
+        String text;
+    }
+
+}