Package org.hibernate.engine.internal

Class Versioning

java.lang.Object
org.hibernate.engine.internal.Versioning
public final class Versioning extends Object
Utilities for dealing with optimistic locking values.

  • Method Details

    • seed

      public static Object seed(EntityVersionMapping versionMapping, SharedSessionContractImplementor session)
      Create an initial optimistic locking value according the EntityVersionMapping contract for the version property.
      Parameters:
      versionMapping - The version mapping
      session - The originating session
      Returns:
      The initial optimistic locking value

    • seedVersion

      public static boolean seedVersion(Object entity, Object[] fields, EntityPersister persister, SharedSessionContractImplementor session)
      Create an initial optimistic locking value using the for the version property if required using the Generator contract and inject it into the snapshot state.
      Parameters:
      fields - The current snapshot state
      persister - The persister of the versioned entity
      entity - The entity instance
      session - The originating session
      Returns:
      True if we injected a new version value into the fields array; false otherwise.

    • isNullInitialVersion

      public static boolean isNullInitialVersion(Object initialVersion)
      Determines if the value of the assigned version property should be considered a "null" value, that is, if it is literally null, or if it is a negative integer.
      Parameters:
      initialVersion - The value initially assigned to a version property
      Returns:
      if the value should be considered null for this purpose

    • incrementVersion

      public static Object incrementVersion(Object entity, Object currentVersion, EntityPersister persister, SharedSessionContractImplementor session)
      Generate the next increment in the optimistic locking value according the Generator contract for the version property.
      Parameters:
      entity - The entity instance
      currentVersion - The current version
      persister - The persister of the versioned entity
      session - The originating session
      Returns:
      The incremented optimistic locking value.

    • increment

      public static Object increment(Object version, EntityVersionMapping versionMapping, SharedSessionContractImplementor session)
      Generate the next increment in the optimistic locking value according the VersionJavaType contract for the version property.
      Parameters:
      version - The current version
      versionMapping - The version mapping
      session - The originating session
      Returns:
      The incremented optimistic locking value.

    • setVersion

      public static void setVersion(Object[] fields, Object version, EntityPersister persister)
      Inject the optimistic locking value into the entity state snapshot.
      Parameters:
      fields - The state snapshot
      version - The optimistic locking value
      persister - The entity persister

    • getVersion

      public static Object getVersion(Object[] fields, EntityPersister persister)
      Extract the optimistic locking value out of the entity state snapshot.
      Parameters:
      fields - The state snapshot
      persister - The entity persister
      Returns:
      The extracted optimistic locking value

    • isVersionIncrementRequired

      public static boolean isVersionIncrementRequired(int[] dirtyProperties, boolean hasDirtyCollections, boolean[] propertyVersionability)
      Do we need to increment the version number, given the dirty properties?
      Parameters:
      dirtyProperties - The array of property indexes which were deemed dirty
      hasDirtyCollections - Were any collections found to be dirty (structurally changed)
      propertyVersionability - An array indicating versionability of each property.
      Returns:
      True if a version increment is required; false otherwise.