@Override public Serializable locateGenerationContext(SharedSessionContractImplementor session, Object incomingObject) { return session.getEntityPersister( entityName, incomingObject ).getIdentifier( incomingObject, session ); } }
@Override public int getHashCode(Object x, SessionFactoryImplementor factory) { EntityPersister persister = getAssociatedEntityPersister( factory ); if ( !persister.canExtractIdOutOfEntity() ) { return super.getHashCode( x ); } final Serializable id; if ( x instanceof HibernateProxy ) { id = ( (HibernateProxy) x ).getHibernateLazyInitializer().getIdentifier(); } else { final Class mappedClass = persister.getMappedClass(); if ( mappedClass.isAssignableFrom( x.getClass() ) ) { id = persister.getIdentifier( x ); } else { id = (Serializable) x; } } return persister.getIdentifierType().getHashCode( id, factory ); }
private Object getIdentifierFromPersister(Object entity) { Class<?> entityClass = Hibernate.getClass( entity ); final EntityPersister persister; try { persister = sessionFactory.getMetamodel().entityPersister( entityClass ); if ( persister == null ) { throw new IllegalArgumentException( entityClass.getName() + " is not an entity" ); } } catch (MappingException ex) { throw new IllegalArgumentException( entityClass.getName() + " is not an entity", ex ); } return persister.getIdentifier( entity, null ); }
/** * make sure user didn't mangle the id */ public void checkId(Object object, EntityPersister persister, Serializable id, SessionImplementor session) throws HibernateException { if ( id != null && id instanceof DelayedPostInsertIdentifier ) { // this is a situation where the entity id is assigned by a post-insert generator // and was saved outside the transaction forcing it to be delayed return; } if ( persister.canExtractIdOutOfEntity() ) { Serializable oid = persister.getIdentifier( object, session ); if ( id == null ) { throw new AssertionFailure( "null id in " + persister.getEntityName() + " entry (don't flush the Session after an exception occurs)" ); } if ( !persister.getIdentifierType().isEqual( id, oid, session.getFactory() ) ) { throw new HibernateException( "identifier of an instance of " + persister.getEntityName() + " was altered from " + id + " to " + oid ); } } }
public Serializable generate(SharedSessionContractImplementor session, Object obj) throws HibernateException { //TODO: cache the persister, this shows up in yourkit final Serializable id = session.getEntityPersister( entityName, obj ).getIdentifier( obj, session ); if ( id == null ) { throw new IdentifierGenerationException( "ids for this class must be manually assigned before calling save(): " + entityName ); } return id; }
public static Object getIdentifier(SessionImplementor session, String entityName, Object obj) { if ( obj == null ) { return null; } if ( obj instanceof HibernateProxy ) { final HibernateProxy hibernateProxy = (HibernateProxy) obj; return hibernateProxy.getHibernateLazyInitializer().getIdentifier(); } return session.getEntityPersister( entityName, obj ).getIdentifier( obj, session ); }
private Serializable getIdentifier(EventSource session, Object obj) { Serializable id = null; if ( obj != null ) { id = session.getContextEntityIdentifier( obj ); if ( id == null ) { id = session.getSessionFactory().getMetamodel().entityPersister( obj.getClass() ).getIdentifier( obj, session ); } } return id; }
SessionImplementor session) { Serializable id = persister.getIdentifier( entity, session ); if ( id == null ) {
@Override public void delete(String entityName, Object entity) { checkOpen(); EntityPersister persister = getEntityPersister( entityName, entity ); Serializable id = persister.getIdentifier( entity, this ); Object version = persister.getVersion( entity ); persister.delete( id, version, entity, this ); }
private void logCannotResolveNonNullableTransientDependencies(SharedSessionContractImplementor session) { for ( Map.Entry<Object,Set<AbstractEntityInsertAction>> entry : dependentActionsByTransientEntity.entrySet() ) { final Object transientEntity = entry.getKey(); final String transientEntityName = session.guessEntityName( transientEntity ); final Serializable transientEntityId = session.getFactory().getMetamodel().entityPersister( transientEntityName ).getIdentifier( transientEntity, session ); final String transientEntityString = MessageHelper.infoString( transientEntityName, transientEntityId ); final Set<String> dependentEntityStrings = new TreeSet<>(); final Set<String> nonNullableTransientPropertyPaths = new TreeSet<>(); for ( AbstractEntityInsertAction dependentAction : entry.getValue() ) { dependentEntityStrings.add( MessageHelper.infoString( dependentAction.getEntityName(), dependentAction.getId() ) ); for ( String path : dependenciesByAction.get( dependentAction ).getNonNullableTransientPropertyPaths( transientEntity ) ) { final String fullPath = dependentAction.getEntityName() + '.' + path; nonNullableTransientPropertyPaths.add( fullPath ); } } LOG.cannotResolveNonNullableTransientDependencies( transientEntityString, dependentEntityStrings, nonNullableTransientPropertyPaths ); } }
private void disallowDeletionOfDetached(DeleteEvent event) { EventSource source = event.getSession(); String entityName = event.getEntityName(); EntityPersister persister = source.getEntityPersister( entityName, event.getObject() ); Serializable id = persister.getIdentifier( event.getObject(), source ); entityName = entityName == null ? source.guessEntityName( event.getObject() ) : entityName; throw new IllegalArgumentException("Removing a detached instance "+ entityName + "#" + id); }
/** * Get the id value from the owning entity key, usually the same as the key, but might be some * other property, in the case of property-ref * * @param key The collection owner key * @param session The session from which the request is originating. * @return The collection owner's id, if it can be obtained from the key; * otherwise, null is returned */ public Serializable getIdOfOwnerOrNull(Serializable key, SharedSessionContractImplementor session) { Serializable ownerId = null; if ( foreignKeyPropertyName == null ) { ownerId = key; } else { Type keyType = getPersister( session ).getKeyType(); EntityPersister ownerPersister = getPersister( session ).getOwnerEntityPersister(); // TODO: Fix this so it will work for non-POJO entity mode Class ownerMappedClass = ownerPersister.getMappedClass(); if ( ownerMappedClass.isAssignableFrom( keyType.getReturnedClass() ) && keyType.getReturnedClass().isInstance( key ) ) { // the key is the owning entity itself, so get the ID from the key ownerId = ownerPersister.getIdentifier( key, session ); } else { // TODO: check if key contains the owner ID } } return ownerId; }
private static Serializable determineEntityId( Object entity, AssociationType associationType, SharedSessionContractImplementor session, SessionFactoryImplementor sessionFactory) { if ( entity == null ) { return null; } if ( HibernateProxy.class.isInstance( entity ) ) { // entity is a proxy, so we know it is not transient; just return ID from proxy return ( (HibernateProxy) entity ).getHibernateLazyInitializer().getIdentifier(); } if ( session != null ) { final EntityEntry pcEntry = session.getPersistenceContext().getEntry( entity ); if ( pcEntry != null ) { // entity managed; return ID. return pcEntry.getId(); } } final EntityPersister persister = resolveEntityPersister( entity, associationType, session, sessionFactory ); return persister.getIdentifier( entity, session ); }
private boolean existsInDatabase(Object entity, EventSource source, EntityPersister persister) { EntityEntry entry = source.getPersistenceContext().getEntry( entity ); if ( entry == null ) { Serializable id = persister.getIdentifier( entity, source ); if ( id != null ) { final EntityKey key = source.generateEntityKey( id, persister ); final Object managedEntity = source.getPersistenceContext().getEntity( key ); entry = source.getPersistenceContext().getEntry( managedEntity ); } } return entry != null && entry.isExistsInDatabase(); }
protected Serializable getCollectionKey( CollectionPersister persister, Object owner, EntityEntry ownerEntry, SharedSessionContractImplementor session) { final CollectionType collectionType = persister.getCollectionType(); if ( ownerEntry != null ) { // this call only works when the owner is associated with the Session, which is not always the case return collectionType.getKeyOfOwner( owner, session ); } if ( collectionType.getLHSPropertyName() == null ) { // collection key is defined by the owning entity identifier return persister.getOwnerEntityPersister().getIdentifier( owner, session ); } else { return (Serializable) persister.getOwnerEntityPersister().getPropertyValue( owner, collectionType.getLHSPropertyName() ); } }
@SuppressWarnings({"unchecked"}) private void entityIsDeleted(PersistEvent event, Map createCache) { final EventSource source = event.getSession(); final Object entity = source.getPersistenceContext().unproxy( event.getObject() ); final EntityPersister persister = source.getEntityPersister( event.getEntityName(), entity ); LOG.tracef( "un-scheduling entity deletion [%s]", MessageHelper.infoString( persister, persister.getIdentifier( entity, source ), source.getFactory() ) ); if ( createCache.put( entity, entity ) == null ) { justCascade( createCache, source, entity, persister ); } } }
protected void entityIsTransient(MergeEvent event, Map copyCache) { LOG.trace( "Merging transient instance" ); final Object entity = event.getEntity(); final EventSource source = event.getSession(); final String entityName = event.getEntityName(); final EntityPersister persister = source.getEntityPersister( entityName, entity ); final Serializable id = persister.hasIdentifierProperty() ? persister.getIdentifier( entity, source ) : null; if ( copyCache.containsKey( entity ) ) { persister.setIdentifier( copyCache.get( entity ), id, source ); } else { ( (MergeContext) copyCache ).put( entity, source.instantiate( persister, id ), true ); //before cascade! } final Object copy = copyCache.get( entity ); // cascade first, so that all unsaved objects get their // copy created before we actually copy //cascadeOnMerge(event, persister, entity, copyCache, Cascades.CASCADE_BEFORE_MERGE); super.cascadeBeforeSave( source, persister, entity, copyCache ); copyValues( persister, entity, copy, source, copyCache, ForeignKeyDirection.FROM_PARENT ); saveTransientEntity( copy, entityName, event.getRequestedId(), source, copyCache ); // cascade first, so that all unsaved objects get their // copy created before we actually copy super.cascadeAfterSave( source, persister, entity, copyCache ); copyValues( persister, entity, copy, source, copyCache, ForeignKeyDirection.TO_PARENT ); event.setResult( copy ); }
@Override public void update(String entityName, Object entity) { checkOpen(); EntityPersister persister = getEntityPersister( entityName, entity ); Serializable id = persister.getIdentifier( entity, this ); Object[] state = persister.getPropertyValues( entity ); Object oldVersion; if ( persister.isVersioned() ) { oldVersion = persister.getVersion( entity ); Object newVersion = Versioning.increment( oldVersion, persister.getVersionType(), this ); Versioning.setVersion( state, newVersion, persister ); persister.setPropertyValues( entity, state ); } else { oldVersion = null; } persister.update( id, state, null, false, null, oldVersion, entity, null, this ); }
final Serializable id = persister.getIdentifier( target, null );
if (entry==null) { final EntityPersister persister = source.getEntityPersister( event.getEntityName(), entity ); final Serializable id = persister.getIdentifier( entity, source ); if ( !ForeignKeys.isNotTransient( event.getEntityName(), entity, Boolean.FALSE, source ) ) { throw new TransientObjectException(