Code example for SessionImplementor

Methods: getEntityPersistergetFactorygetInterceptorgetPersistenceContext

0
			// if it was a reference to self, don't need to nullify 
			// unless we are using native id generation, in which 
			// case we definitely need to nullify 
			if ( object == self ) { 
				return isEarlyInsert || (
					isDelete &&
					session.getFactory()
						.getDialect()
						.hasSelfReferentialForeignKeyBug()
				); 
			} 
	 
			// See if the entity is already bound to this session, if not look at the 
			// entity identifier and assume that the entity is persistent if the 
			// id is not "unsaved" (that is, we rely on foreign keys to keep 
			// database integrity) 
	 
			EntityEntry entityEntry = session.getPersistenceContext().getEntry(object);
			if ( entityEntry==null ) {
				return isTransient(entityName, object, null, session);
			} 
			else { 
				return entityEntry.isNullifiable(isEarlyInsert, session);
			} 
	 
		} 
		 
	} 
	 
	/** 
	 * Is this instance persistent or detached? 
	 * If <tt>assumed</tt> 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 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, which we know is not persistent, actually transient? 
	 * If <tt>assumed</tt> 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 ),
				persister
		); 
		return snapshot==null; 
 
	} 
 
	/** 
	 * 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 Serializable getEntityIdentifierIfNotUnsaved(
			final String entityName, 
			final Object object,  
			final SessionImplementor session)
	throws HibernateException {
		if ( object == null ) { 
			return null; 
		} 
		else { 
			Serializable id = session.getContextEntityIdentifier( object );
			if ( id == null ) {
				// context-entity-identifier returns null explicitly if the entity 
				// is not associated with the persistence context; so make some 
				// deeper checks... 
				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 );
			} 
			return id;
		} 
	} 
 
} 
Connect your IDE to all the code out there  Get Codota for Java