public DelWorkUnit( SessionImplementor sessionImplementor, String entityName, EnversService enversService, Serializable id, EntityPersister entityPersister, Object[] state) { super( sessionImplementor, entityName, enversService, id, RevisionType.DEL ); this.state = state; this.entityPersister = entityPersister; this.propertyNames = entityPersister.getPropertyNames(); }
@Override public String getName() { return persister.getPropertyNames()[index]; }
public HibernateTraversableResolver( EntityPersister persister, ConcurrentHashMap<EntityPersister, Set<String>> associationsPerEntityPersister, SessionFactoryImplementor factory) { this.associations = associationsPerEntityPersister.get( persister ); if (this.associations == null) { this.associations = new HashSet<String>(); addAssociationsToTheSetForAllProperties( persister.getPropertyNames(), persister.getPropertyTypes(), "", factory ); associationsPerEntityPersister.put( persister, associations ); } }
@Override @SuppressWarnings("unchecked") public Object destructure(Object structured, SessionFactoryImplementor factory) { final Map map = (Map) structured; final String subclass = (String) map.get( SUBCLASS_KEY ); final Object version = map.get( VERSION_KEY ); final EntityPersister subclassPersister = factory.getEntityPersister( subclass ); final String[] names = subclassPersister.getPropertyNames(); final Serializable[] disassembledState = new Serializable[names.length]; for ( int i = 0; i < names.length; i++ ) { disassembledState[i] = (Serializable) map.get( names[i] ); } return new StandardCacheEntryImpl( disassembledState, subclass, version ); }
@Override @SuppressWarnings("unchecked") public Object structure(Object item) { final CacheEntry entry = (CacheEntry) item; final String[] names = persister.getPropertyNames(); final Map map = new HashMap( names.length + 3, 1f ); map.put( SUBCLASS_KEY, entry.getSubclass() ); map.put( VERSION_KEY, entry.getVersion() ); for ( int i=0; i<names.length; i++ ) { map.put( names[i], entry.getDisassembledState()[i] ); } return map; } }
private DirtyCheckAttributeInfoImpl(FlushEntityEvent event) { this.event = event; this.persister = event.getEntityEntry().getPersister(); this.numberOfAttributes = persister.getPropertyNames().length; }
private SimpleNaturalIdLoadAccessImpl(EntityPersister entityPersister) { super( entityPersister ); if ( entityPersister.getNaturalIdentifierProperties().length != 1 ) { throw new HibernateException( String.format( "Entity [%s] did not define a simple natural id", entityPersister.getEntityName() ) ); } final int naturalIdAttributePosition = entityPersister.getNaturalIdentifierProperties()[0]; this.naturalIdAttributeName = entityPersister.getPropertyNames()[naturalIdAttributePosition]; }
private void logDirtyProperties(Serializable id, int[] dirtyProperties, EntityPersister persister) { if ( dirtyProperties != null && dirtyProperties.length > 0 && LOG.isTraceEnabled() ) { final String[] allPropertyNames = persister.getPropertyNames(); final String[] dirtyPropertyNames = new String[dirtyProperties.length]; for ( int i = 0; i < dirtyProperties.length; i++ ) { dirtyPropertyNames[i] = allPropertyNames[dirtyProperties[i]]; } LOG.tracev( "Found dirty properties [{0}] : {1}", MessageHelper.infoString( persister.getEntityName(), id ), Arrays.toString( dirtyPropertyNames ) ); } }
public CachedNaturalId(EntityPersister persister, Object[] values) { this.persister = persister; this.values = values; final int prime = 31; int hashCodeCalculation = 1; hashCodeCalculation = prime * hashCodeCalculation + persister.hashCode(); final int[] naturalIdPropertyIndexes = persister.getNaturalIdentifierProperties(); naturalIdTypes = new Type[ naturalIdPropertyIndexes.length ]; int i = 0; for ( int naturalIdPropertyIndex : naturalIdPropertyIndexes ) { final Type type = persister.getPropertyType( persister.getPropertyNames()[ naturalIdPropertyIndex ] ); naturalIdTypes[i] = type; final int elementHashCode = values[i] == null ? 0 :type.getHashCode( values[i], persister.getFactory() ); hashCodeCalculation = prime * hashCodeCalculation + elementHashCode; i++; } this.hashCode = hashCodeCalculation; }
/** * Get the property type of a given property in the specified entity. * * @param session the session * @param entityName the entity name * @param propertyName the property name * @return the property type of the property or {@code null} if the property name isn't found. */ private Type getPropertyType(SessionImplementor session, String entityName, String propertyName) { // rather than rely on QueryException from calling getPropertyType(), this allows a non-failure way // to determine whether to return null or lookup the value safely. final EntityPersister persister = session.getSessionFactory().getMetamodel().entityPersister( entityName ); for ( String name : persister.getPropertyNames() ) { if ( name.equals( propertyName ) ) { return persister.getPropertyType( propertyName ); } } return null; } }
public AddWorkUnit( SessionImplementor sessionImplementor, String entityName, EnversService enversService, Serializable id, EntityPersister entityPersister, Object[] state) { super( sessionImplementor, entityName, enversService, id, RevisionType.ADD ); this.data = new HashMap<>(); this.state = state; this.enversService.getEntitiesConfigurations().get( getEntityName() ).getPropertyMapper().map( sessionImplementor, data, entityPersister.getPropertyNames(), state, null ); }
public ModWorkUnit( SessionImplementor sessionImplementor, String entityName, EnversService enversService, Serializable id, EntityPersister entityPersister, Object[] newState, Object[] oldState) { super( sessionImplementor, entityName, enversService, id, RevisionType.MOD ); this.entityPersister = entityPersister; this.oldState = oldState; this.newState = newState; this.data = new HashMap<>(); this.changes = enversService.getEntitiesConfigurations().get( getEntityName() ).getPropertyMapper().map( sessionImplementor, data, entityPersister.getPropertyNames(), newState, oldState ); }
public AddWorkUnit( SessionImplementor sessionImplementor, String entityName, EnversService enversService, Serializable id, Map<String, Object> data) { super( sessionImplementor, entityName, enversService, id, RevisionType.ADD ); this.data = data; final String[] propertyNames = sessionImplementor.getFactory().getMetamodel() .entityPersister( getEntityName() ) .getPropertyNames(); this.state = ArraysTools.mapToArray( data, propertyNames ); }
@Override public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) { final EntityPersister meta = criteriaQuery.getFactory().getEntityPersister( criteriaQuery.getEntityName( criteria ) ); final String[] propertyNames = meta.getPropertyNames(); final Type[] propertyTypes = meta.getPropertyTypes(); final Object[] values = meta.getPropertyValues( exampleEntity ); final List<TypedValue> list = new ArrayList<TypedValue>(); for ( int i=0; i<propertyNames.length; i++ ) { final Object value = values[i]; final Type type = propertyTypes[i]; final String name = propertyNames[i]; final boolean isVersionProperty = i == meta.getVersionProperty(); if ( ! isVersionProperty && isPropertyIncluded( value, name, type ) ) { if ( propertyTypes[i].isComponentType() ) { addComponentTypedValues( name, value, (CompositeType) type, list, criteria, criteriaQuery ); } else { addPropertyTypedValue( value, type, list ); } } } return list.toArray( new TypedValue[ list.size() ] ); }
public enum NullabilityCheckType { CREATE, UPDATE, DELETE }
private Object[] postUpdateDBState(PostUpdateEvent event) { final Object[] newDbState = event.getState().clone(); if ( event.getOldState() != null ) { final EntityPersister entityPersister = event.getPersister(); for ( int i = 0; i < entityPersister.getPropertyNames().length; ++i ) { if ( !entityPersister.getPropertyUpdateability()[i] ) { // Assuming that PostUpdateEvent#getOldState() returns database state of the record before modification. // Otherwise, we would have to execute SQL query to be sure of @Column(updatable = false) column value. newDbState[i] = event.getOldState()[i]; } } } return newDbState; }
public void onPreLoad(PreLoadEvent event) { EntityPersister persister = event.getPersister(); event.getSession() .getInterceptor() .onLoad( event.getEntity(), event.getId(), event.getState(), persister.getPropertyNames(), persister.getPropertyTypes() ); }
@Override public void noCascade( EventSource session, Object parent, EntityPersister persister, Type propertyType, int propertyIndex) { if ( propertyType.isEntityType() ) { Object child = persister.getPropertyValue( parent, propertyIndex ); String childEntityName = ((EntityType) propertyType).getAssociatedEntityName( session.getFactory() ); if ( child != null && !isInManagedState( child, session ) && !(child instanceof HibernateProxy) //a proxy cannot be transient and it breaks ForeignKeys.isTransient && ForeignKeys.isTransient( childEntityName, child, null, session ) ) { String parentEntityName = persister.getEntityName(); String propertyName = persister.getPropertyNames()[propertyIndex]; throw new TransientPropertyValueException( "object references an unsaved transient instance - save the transient instance before flushing", childEntityName, parentEntityName, propertyName ); } } }
@Override public boolean onPreUpdate(PreUpdateEvent event) { executed = true; final Object[] oldValues = event.getOldState(); final String[] properties = event.getPersister().getPropertyNames(); // Iterate through all fields of the updated object for ( int i = 0; i < properties.length; i++ ) { if ( oldValues != null && oldValues[i] != null ) { if ( ! Hibernate.isInitialized( oldValues[i] ) ) { // force any proxies and/or collections to initialize to illustrate HHH-2763 foundAny = true; Hibernate.initialize( oldValues ); } } } return true; } }
protected boolean invokeInterceptor( SessionImplementor session, Object entity, EntityEntry entry, final Object[] values, EntityPersister persister) { boolean isDirty = false; if ( entry.getStatus() != Status.DELETED ) { if ( callbackRegistry.preUpdate( entity ) ) { isDirty = copyState( entity, persister.getPropertyTypes(), values, session.getFactory() ); } } final boolean answerFromInterceptor = session.getInterceptor().onFlushDirty( entity, entry.getId(), values, entry.getLoadedState(), persister.getPropertyNames(), persister.getPropertyTypes() ); return answerFromInterceptor || isDirty; }