public static Serializable getEntityIdentifierIfNotUnsaved(String entityName,
    Object object,
    SessionImplementor session) throws HibernateException 
{
		if ( object == null ) {
			return null;
		}
		else {
			Serializable id = session.getContextEntityIdentifier(object);
			if ( id==null ) {
				if ( isTransient(entityName, object, Boolean.FALSE, session) ) {
					throw new TransientObjectException(
							"object references an unsaved transient instance - save the transient instance before flushing: " +
							entityName == null ? session.guessEntityName( object ) : entityName
					);
				}
				id = session.getEntityPersister(entityName, object)
						.getIdentifier( object, session.getEntityMode() );
			}
			return id;
		}
}

Return the identifier of the persistent or transient object, or throw an exception if the instance is "unsaved" Used by OneToOneType and ManyToOneType to determine what id value should be used for an object that may or may not be associated with the session. This does a "best guess" using any/all info available to use (not just the EntityEntry).

 public static boolean isNotTransient(String entityName,
    Object entity,
    Boolean assumed,
    SessionImplementor session) throws HibernateException 
{
		if (entity instanceof HibernateProxy) return true;
		if ( session.getPersistenceContext().isEntryFor(entity) ) return true;
		return !isTransient(entityName, entity, assumed, session);
}

Is this instance persistent or detached? If assumed is non-null, don't hit the database to make the determination, instead assume that value; the client code must be prepared to "recover" in the case that this assumed result is incorrect.

 public static boolean isTransient(String entityName,
    Object entity,
    Boolean assumed,
    SessionImplementor session) throws HibernateException 
{
		
		if (entity==LazyPropertyInitializer.UNFETCHED_PROPERTY) {
			// an unfetched association can only point to
			// an entity that already exists in the db
			return false;
		}
		// let the interceptor inspect the instance to decide
		Boolean isUnsaved = session.getInterceptor().isTransient(entity);
		if (isUnsaved!=null) return isUnsaved.booleanValue();
		// let the persister inspect the instance to decide
		EntityPersister persister = session.getEntityPersister(entityName, entity);
		isUnsaved = persister.isTransient(entity, session);
		if (isUnsaved!=null) return isUnsaved.booleanValue();
		// we use the assumed value, if there is one, to avoid hitting
		// the database
		if (assumed!=null) return assumed.booleanValue();
		// hit the database, after checking the session cache for a snapshot
		Object[] snapshot = session.getPersistenceContext()
		        .getDatabaseSnapshot( persister.getIdentifier( entity, session.getEntityMode() ), persister );
		return snapshot==null;
}

Is this instance, which we know is not persistent, actually transient? If assumed is non-null, don't hit the database to make the determination, instead assume that value; the client code must be prepared to "recover" in the case that this assumed result is incorrect.