public Object replace( Object original, Object target, SessionImplementor session, Object owner, Map copyCache ) throws HibernateException { if ( isEqual( original, target, session.getEntityMode() ) ) return original; return deepCopy( original, session.getEntityMode(), session.getFactory() ); }
public boolean isNull(Object owner, SessionImplementor session) { if ( propertyName != null ) { EntityPersister ownerPersister = session.getFactory().getEntityPersister(entityName); Serializable id = session.getEntityIdentifier(owner); EntityKey entityKey = new EntityKey( id, ownerPersister, session.getEntityMode() ); return session.getPersistenceContext().isPropertyNull( entityKey, getPropertyName() ); } else { return false; } }
public Serializable generate(SessionImplementor session, Object obj) throws HibernateException { final Serializable id = session.getEntityPersister( entityName, obj ) //TODO: cache the persister, this shows up in yourkit .getIdentifier( obj, session.getEntityMode() ); if (id==null) { throw new IdentifierGenerationException( "ids for this class must be manually assigned before calling save(): " + entityName ); } return id; }
protected final boolean isConnectedToSession() { return session!=null && session.isOpen() && session.getPersistenceContext().containsProxy(this); }
public final void close() throws HibernateException { try { // not absolutely necessary, but does help with aggressive release session.getBatcher().closeQueryStatement(ps, resultSet); } catch (SQLException sqle) { throw JDBCExceptionHelper.convert( session.getFactory().getSQLExceptionConverter(), sqle, "could not close results" ); } }
private Object getReplacement() { final SessionImplementor session = getSession(); if ( isUninitialized() && session != null && session.isOpen()) { final EntityKey key = new EntityKey( getIdentifier(), session.getFactory().getEntityPersister( getEntityName() ), session.getEntityMode() ); final Object entity = session.getPersistenceContext().getEntity(key); if (entity!=null) setImplementation( entity ); } if ( isUninitialized() ) { if (replacement==null) { replacement = serializableProxy(); } return replacement; } else { return getTarget(); } }
/** * Handle the given update event. * * @param event The update event to be handled. * @throws HibernateException */ protected void entityIsDetached(SaveOrUpdateEvent event) throws HibernateException { log.trace("updating detached instance"); if ( event.getSession().getPersistenceContext().isEntryFor( event.getEntity() ) ) { //TODO: assertion only, could be optimized away throw new AssertionFailure("entity was persistent"); } Object entity = event.getEntity(); EntityPersister persister = event.getSession().getEntityPersister( event.getEntityName(), entity ); event.setRequestedId( getUpdateId( entity, persister, event.getRequestedId(), event.getSession().getEntityMode() ) ); performUpdate(event, entity, persister); }
/** * Return the underlying persistent object in the given <tt>Session</tt>, or null, * do not initialize the proxy */ public final Object getImplementation(SessionImplementor s) throws HibernateException { return s.getPersistenceContext().getEntity( new EntityKey( getIdentifier(), s.getFactory().getEntityPersister( getEntityName() ), s.getEntityMode() ) ); }
Boolean isUnsaved = session.getInterceptor().isTransient(entity); if (isUnsaved!=null) return isUnsaved.booleanValue(); EntityPersister persister = session.getEntityPersister(entityName, entity); isUnsaved = persister.isTransient(entity, session); if (isUnsaved!=null) return isUnsaved.booleanValue(); Object[] snapshot = session.getPersistenceContext() .getDatabaseSnapshot( persister.getIdentifier( entity, session.getEntityMode() ), persister ); return snapshot==null;
private Object intercept(Object target, String fieldName, Object value) { if ( initializing ) return value; if ( uninitializedFields != null && uninitializedFields.contains( fieldName ) ) { if ( session == null ) { throw new LazyInitializationException( "entity with lazy properties is not associated with a session" ); } else if ( !session.isOpen() || !session.isConnected() ) { throw new LazyInitializationException( "session is not connected" ); } final Object result; initializing = true; try { result = ( ( LazyPropertyInitializer ) session.getFactory().getEntityPersister( entityName ) ) .initializeLazyProperty( fieldName, target, session ); } finally { initializing = false; } uninitializedFields = null; //let's assume that there is only one lazy fetch group, for now! return result; } else { return value; } }
Serializable id = session.getContextEntityIdentifier( object ); if ( id == null ) { 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() );
Serializable id = session.getEntityIdentifier(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: " + session.guessEntityName(object) ); id = session.getEntityPersister(entityName, object).getIdentifier( object, session.getEntityMode() );
protected void before() { if ( flushMode!=null ) { sessionFlushMode = getSession().getFlushMode(); getSession().setFlushMode(flushMode); } if ( cacheMode!=null ) { sessionCacheMode = getSession().getCacheMode(); getSession().setCacheMode(cacheMode); } }
/** * Get the current snapshot from the session */ protected final Serializable getSnapshot() { return session.getPersistenceContext().getSnapshot(this); }
protected void set(PreparedStatement st, Object value, int index, SessionImplementor session) throws SQLException { if ( value == null ) { st.setNull( index, sqlTypes( null )[0] ); } else { byte[] toSet = unWrap( value ); final boolean useInputStream = session.getFactory().getDialect().useInputStreamToInsertBlob(); if ( useInputStream ) { st.setBinaryStream( index, new ByteArrayInputStream( toSet ), toSet.length ); } else { st.setBlob( index, Hibernate.getLobCreator( session ).createBlob( toSet ) ); } } }
public boolean isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session) throws HibernateException { return checkable[0] ? ! isEqual( old, current, session.getEntityMode() ) : false; }
public void execute() throws HibernateException { final PersistentCollection collection = getCollection(); getPersister().recreate( collection, getKey(), getSession() ); getSession().getPersistenceContext() .getCollectionEntry(collection) .afterAction(collection); evict(); if ( getSession().getFactory().getStatistics().isStatisticsEnabled() ) { getSession().getFactory().getStatisticsImplementor() .recreateCollection( getPersister().getRole() ); } }
private static CompassEventListener findEventListener(Session session) { PostInsertEventListener[] listeners = ((SessionImplementor) session).getListeners().getPostInsertEventListeners(); return findEventListener(listeners); }
public final void initialize() throws HibernateException { if (target==null) { if ( session==null ) { throw new LazyInitializationException("could not initialize proxy - no Session"); } else if ( !session.isOpen() ) { throw new LazyInitializationException("could not initialize proxy - the owning Session was closed"); } else if ( !session.isConnected() ) { throw new LazyInitializationException("could not initialize proxy - the owning Session is disconnected"); } else { target = session.immediateLoad(entityName, id); } } }
public void execute() throws HibernateException { EntityPersister persister = getPersister(); SessionImplementor session = getSession(); Object instance = getInstance(); PreInsertEvent preEvent = new PreInsertEvent( instance, null, state, persister, session ); final boolean veto = session.getListeners().getPreInsertEventListener().onPreInsert( preEvent ); // Don't need to lock the cache here, since if someone // else inserted the same pk first, the insert would fail if ( !veto ) generatedId = persister.insert( state, instance, session ); //TODO: this bit actually has to be called after all cascades! // but since identity insert is called *synchronously*, // instead of asynchronously as other actions, it isn't /*if ( persister.hasCache() && !persister.isCacheInvalidationRequired() ) { cacheEntry = new CacheEntry(object, persister, session); persister.getCache().insert(generatedId, cacheEntry); }*/ PostInsertEvent postEvent = new PostInsertEvent( instance, generatedId, state, getPersister(), session ); session.getListeners().getPostInsertEventListener().onPostInsert( postEvent ); if ( getSession().getFactory().getStatistics().isStatisticsEnabled() && !veto ) { getSession().getFactory().getStatisticsImplementor() .insertEntity( getPersister().getEntityName() ); } }