@Override protected boolean visitCollectionsBeforeSave( Object entity, Serializable id, Object[] values, Type[] types, EventSource source) { //TODO: we use two visitors here, inefficient! OnReplicateVisitor visitor = new OnReplicateVisitor( source, id, entity, false ); visitor.processEntityPropertyValues( values, types ); return super.visitCollectionsBeforeSave( entity, id, values, types, source ); }
@Override public Object processCollection(Object collection, CollectionType type) throws HibernateException { if ( collection == CollectionType.UNFETCHED_COLLECTION ) { return null; } final EventSource session = getSession(); final CollectionPersister persister = session.getFactory().getMetamodel().collectionPersister( type.getRole() ); if ( isUpdate ) { removeCollection( persister, extractCollectionKeyFromOwner( persister ), session ); } if ( collection != null && collection instanceof PersistentCollection ) { final PersistentCollection wrapper = (PersistentCollection) collection; wrapper.setCurrentSession( (SessionImplementor) session ); if ( wrapper.wasInitialized() ) { session.getPersistenceContext().addNewCollection( persister, wrapper ); } else { reattachCollection( wrapper, type ); } } else { // otherwise a null or brand new collection // this will also (inefficiently) handle arrays, which // have no snapshot, so we can't do any better //processArrayOrNewCollection(collection, type); } return null; }
private void performReplication( Object entity, Serializable id, Object version, EntityPersister persister, ReplicationMode replicationMode, EventSource source) throws HibernateException { if ( LOG.isTraceEnabled() ) { LOG.tracev( "Replicating changes to {0}", MessageHelper.infoString( persister, id, source.getFactory() ) ); } new OnReplicateVisitor( source, id, entity, true ).process( entity, persister ); source.getPersistenceContext().addEntity( entity, ( persister.isMutable() ? Status.MANAGED : Status.READ_ONLY ), null, source.generateEntityKey( id, persister ), version, LockMode.NONE, true, persister, true ); cascadeAfterReplicate( entity, persister, replicationMode, source ); }
Object processCollection(Object collection, CollectionType type) throws HibernateException { if ( collection == CollectionType.UNFETCHED_COLLECTION ) { return null; } EventSource session = getSession(); CollectionPersister persister = session.getFactory().getCollectionPersister( type.getRole() ); if ( isUpdate ) { removeCollection( persister, extractCollectionKeyFromOwner( persister ), session ); } if ( collection != null && ( collection instanceof PersistentCollection ) ) { PersistentCollection wrapper = ( PersistentCollection ) collection; wrapper.setCurrentSession( session ); if ( wrapper.wasInitialized() ) { session.getPersistenceContext().addNewCollection( persister, wrapper ); } else { reattachCollection( wrapper, type ); } } else { // otherwise a null or brand new collection // this will also (inefficiently) handle arrays, which // have no snapshot, so we can't do any better //processArrayOrNewCollection(collection, type); } return null; }
@Override protected boolean visitCollectionsBeforeSave(Object entity, Serializable id, Object[] values, Type[] types, EventSource source) { //TODO: we use two visitors here, inefficient! OnReplicateVisitor visitor = new OnReplicateVisitor( source, id, entity, false ); visitor.processEntityPropertyValues( values, types ); return super.visitCollectionsBeforeSave( entity, id, values, types, source ); }
private void performReplication( Object entity, Serializable id, Object version, EntityPersister persister, ReplicationMode replicationMode, EventSource source) throws HibernateException { if ( LOG.isTraceEnabled() ) { LOG.tracev( "Replicating changes to {0}", MessageHelper.infoString( persister, id, source.getFactory() ) ); } new OnReplicateVisitor( source, id, entity, true ).process( entity, persister ); source.getPersistenceContext().addEntity( entity, ( persister.isMutable() ? Status.MANAGED : Status.READ_ONLY ), null, source.generateEntityKey( id, persister ), version, LockMode.NONE, true, persister, true, false ); cascadeAfterReplicate( entity, persister, replicationMode, source ); }
Object processCollection(Object collection, CollectionType type) throws HibernateException { if ( collection == CollectionType.UNFETCHED_COLLECTION ) { return null; } EventSource session = getSession(); CollectionPersister persister = session.getFactory().getCollectionPersister( type.getRole() ); if ( isUpdate ) { removeCollection( persister, extractCollectionKeyFromOwner( persister ), session ); } if ( collection != null && ( collection instanceof PersistentCollection ) ) { PersistentCollection wrapper = ( PersistentCollection ) collection; wrapper.setCurrentSession( session ); if ( wrapper.wasInitialized() ) { session.getPersistenceContext().addNewCollection( persister, wrapper ); } else { reattachCollection( wrapper, type ); } } else { // otherwise a null or brand new collection // this will also (inefficiently) handle arrays, which // have no snapshot, so we can't do any better //processArrayOrNewCollection(collection, type); } return null; }
@Override protected boolean visitCollectionsBeforeSave(Object entity, Serializable id, Object[] values, Type[] types, EventSource source) { //TODO: we use two visitors here, inefficient! OnReplicateVisitor visitor = new OnReplicateVisitor( source, id, entity, false ); visitor.processEntityPropertyValues( values, types ); return super.visitCollectionsBeforeSave( entity, id, values, types, source ); }
private void performReplication( Object entity, Serializable id, Object version, EntityPersister persister, ReplicationMode replicationMode, EventSource source) throws HibernateException { if ( LOG.isTraceEnabled() ) { LOG.tracev( "Replicating changes to {0}", MessageHelper.infoString( persister, id, source.getFactory() ) ); } new OnReplicateVisitor( source, id, entity, true ).process( entity, persister ); source.getPersistenceContext().addEntity( entity, ( persister.isMutable() ? Status.MANAGED : Status.READ_ONLY ), null, source.generateEntityKey( id, persister ), version, LockMode.NONE, true, persister, true, false ); cascadeAfterReplicate( entity, persister, replicationMode, source ); }
@Override public Object processCollection(Object collection, PluralPersistentAttribute collectionAttribute) throws HibernateException { if ( collection == PersistentCollectionDescriptor.UNFETCHED_COLLECTION ) { return null; } final EventSource session = getSession(); final PersistentCollectionDescriptor descriptor = session.getFactory() .getMetamodel() .findCollectionDescriptor( collectionAttribute.getNavigableName() ); if ( isUpdate ) { removeCollection( descriptor, extractCollectionKeyFromOwner( descriptor ), session ); } if ( collection != null && collection instanceof PersistentCollection ) { final PersistentCollection wrapper = (PersistentCollection) collection; wrapper.setCurrentSession( session ); if ( wrapper.wasInitialized() ) { session.getPersistenceContext().addNewCollection( descriptor, wrapper ); } else { reattachCollection( wrapper, descriptor.getNavigableRole() ); } } else { // otherwise a null or brand new collection // this will also (inefficiently) handle arrays, which // have no snapshot, so we can't do any better //processArrayOrNewCollection(collection, type); } return null; }
@Override protected boolean visitCollectionsBeforeSave( Object entity, Object id, Object[] values, List<PersistentAttributeDescriptor> navigables, EventSource source) { //TODO: we use two visitors here, inefficient! OnReplicateVisitor visitor = new OnReplicateVisitor( source, id, entity, false ); visitor.processEntityPropertyValues( values, navigables ); return super.visitCollectionsBeforeSave( entity, id, values, navigables, source ); }
private void performReplication( Object entity, Object id, Object version, EntityTypeDescriptor entityDescriptor, ReplicationMode replicationMode, EventSource source) throws HibernateException { if ( LOG.isTraceEnabled() ) { LOG.tracev( "Replicating changes to {0}", MessageHelper.infoString( entityDescriptor, id, source.getFactory() ) ); } new OnReplicateVisitor( source, id, entity, true ).process( entity, entityDescriptor ); source.getPersistenceContext().addEntity( entity, ( entityDescriptor.getJavaTypeDescriptor().getMutabilityPlan().isMutable() ? Status.MANAGED : Status.READ_ONLY ), null, source.generateEntityKey( id, entityDescriptor ), version, LockMode.NONE, true, entityDescriptor, true ); cascadeAfterReplicate( entity, entityDescriptor, replicationMode, source ); }