protected String getDiscriminatorAlias(Loadable persister, String suffix) { return persister.getDiscriminatorColumnName(); }
final SharedSessionContractImplementor session) throws HibernateException, SQLException { if ( persister.hasSubclasses() ) { final Object discriminatorValue = persister.getDiscriminatorType().nullSafeGet( rs, getEntityAliases()[i].getSuffixedDiscriminatorAlias(), ); final String result = persister.getSubclassForDiscriminatorValue( discriminatorValue ); "Discriminator: " + discriminatorValue, id, persister.getEntityName() ); return persister.getEntityName();
protected String[] getPropertyAliases(Loadable persister, int j) { return persister.getPropertyColumnNames(j); } }
@Override public String[][] getSuffixedPropertyAliases(Loadable persister) { final int size = persister.getPropertyNames().length; final String[][] suffixedPropertyAliases; if (size > 0) { suffixedPropertyAliases = new String[size][]; for ( int j = 0; j < size; j++ ) { suffixedPropertyAliases[j] = getUserProvidedAliases( persister.getPropertyNames()[j], getPropertyAliases( persister, j ) ); suffixedPropertyAliases[j] = StringHelper.unquote( suffixedPropertyAliases[j], persister.getFactory().getDialect() ); intern( suffixedPropertyAliases[j] ); } } else { suffixedPropertyAliases = EMPTY_ARRAY_OF_ARRAY_OF_STRINGS; } return suffixedPropertyAliases; }
private String[] determineKeyAlias(Loadable persister, String suffix) { final String[] aliases; final String[] keyColumnsCandidates = getUserProvidedAliases( persister.getIdentifierPropertyName(), null ); if ( keyColumnsCandidates == null ) { aliases = getUserProvidedAliases( "id", getIdentifierAliases(persister, suffix) ); } else { aliases = keyColumnsCandidates; } final String[] rtn = StringHelper.unquote( aliases, persister.getFactory().getDialect() ); intern( rtn ); return rtn; }
final SharedSessionContractImplementor session) throws HibernateException, SQLException { if ( !persister.isInstance( object ) ) { throw new WrongClassException( "loaded object was of wrong class " + object.getClass(), key.getIdentifier(), persister.getEntityName() ); if ( entry.getLockMode().lessThan( requestedLockMode ) ) { if ( persister.isVersioned() ) { checkVersion( i, persister, key.getIdentifier(), object, rs, session );
getEntityAliases()[i].getSuffixedPropertyAliases( persister ); final Object[] values = persister.hydrate( rs, id, ); final Object rowId = persister.hasRowId() ? rs.getObject( rowIdAlias ) : null; if ( ukName != null ) { final int index = ( (UniqueKeyLoadable) persister ).getPropertyIndex( ukName ); final Type type = persister.getPropertyTypes()[index]; rootPersister.getEntityName(), //polymorphism comment above ukName, type.semiResolve( values[index], session, object ), type, persister.getEntityMode(), session.getFactory() );
protected String[] getIdentifierAliases(Loadable persister, String suffix) { return persister.getIdentifierColumnNames(); }
@Override public String getComment() { return "load " + getPersister().getEntityName(); }
/** * Check the version of the object in the <tt>ResultSet</tt> against * the object version in the session cache, throwing an exception * if the version numbers are different */ private void checkVersion( final int i, final Loadable persister, final Serializable id, final Object entity, final ResultSet rs, final SharedSessionContractImplementor session) throws HibernateException, SQLException { Object version = session.getPersistenceContext().getEntry( entity ).getVersion(); if ( version != null ) { //null version means the object is in the process of being loaded somewhere else in the ResultSet final VersionType versionType = persister.getVersionType(); final Object currentVersion = versionType.nullSafeGet( rs, getEntityAliases()[i].getSuffixedVersionAliases(), session, null ); if ( !versionType.isEqual( version, currentVersion ) ) { if ( session.getFactory().getStatistics().isStatisticsEnabled() ) { session.getFactory().getStatistics().optimisticFailure( persister.getEntityName() ); } throw new StaleObjectStateException( persister.getEntityName(), id ); } } }
EntityKey entityKey) { final Loadable loadable = (Loadable) entityReference.getEntityPersister(); if ( ! loadable.hasSubclasses() ) { return entityReference.getEntityPersister().getEntityName(); discriminatorValue = loadable.getDiscriminatorType().nullSafeGet( resultSet, entityReferenceAliases.getColumnAliases().getSuffixedDiscriminatorAlias(), final String result = loadable.getSubclassForDiscriminatorValue( discriminatorValue );
persister.getIdentifierPropertyName(), (String[]) null ); getDiscriminatorAlias(persister, suffix) ); if ( persister.isVersioned() ) { suffixedVersionColumn = suffixedPropertyColumns[ persister.getVersionProperty() ];
/** * Determine the concrete class of an instance in the <tt>ResultSet</tt> * * Copied from Loader#getInstanceClass */ private String getInstanceClass( final Tuple resultset, final int i, final Loadable persister, final Serializable id, final SharedSessionContractImplementor session) throws HibernateException { String discriminatorColumnName = persister.getDiscriminatorColumnName(); if ( discriminatorColumnName == null ) { return persister.getEntityName(); } else { Object value = resultset.get( discriminatorColumnName ); return persister.getSubclassForDiscriminatorValue( value ); } }
for ( int i = 0; i < mainSidePersister.getPropertyNames().length; i++ ) { String candidateProperty = mainSidePersister.getPropertyNames()[i]; Type type = mainSidePersister.getPropertyType( candidateProperty ); if ( Arrays.equals( collectionPersister.getKeyColumnNames(), mainSidePersister.getPropertyColumnNames( i ) ) ) { return candidateProperty;
@Override public Object resolve(Object value, SharedSessionContractImplementor session, Object owner, Boolean overridingEager) throws HibernateException { Object resolvedValue = super.resolve(value, session, owner, overridingEager); if ( isLogicalOneToOne && value != null && getPropertyName() != null ) { EntityEntry entry = session.getPersistenceContext().getEntry( owner ); if ( entry != null ) { final Loadable ownerPersister = (Loadable) session.getFactory().getMetamodel().entityPersister( entry.getEntityName() ); EntityUniqueKey entityKey = new EntityUniqueKey( ownerPersister.getEntityName(), getPropertyName(), value, this, ownerPersister.getEntityMode(), session.getFactory() ); session.getPersistenceContext().addEntity( entityKey, owner ); } } return resolvedValue; }
protected String[] getIdentifierAliases(Loadable persister, String suffix) { return persister.getIdentifierAliases(suffix); }
protected String getDiscriminatorAlias(Loadable persister, String suffix) { return persister.getDiscriminatorAlias(suffix); }
@Override public Object nullSafeGet( ResultSet rs, String name, SharedSessionContractImplementor session, Object owner) throws HibernateException, SQLException { final Object discriminatorValue = underlyingType.nullSafeGet( rs, name, session, owner ); final String entityName = persister.getSubclassForDiscriminatorValue( discriminatorValue ); if ( entityName == null ) { throw new HibernateException( "Unable to resolve discriminator value [" + discriminatorValue + "] to entity name" ); } final EntityPersister entityPersister = session.getEntityPersister( entityName, null ); return ( EntityMode.POJO == entityPersister.getEntityMode() ) ? entityPersister.getMappedClass() : entityName; }
public String[][] getSuffixedPropertyAliases(Loadable persister) { int size = persister.getPropertyNames().length; String[][] suffixedPropertyAliases = new String[size][]; for ( int j = 0; j < size; j++ ) { suffixedPropertyAliases[j] = getUserProvidedAliases( persister.getPropertyNames()[j], getPropertyAliases(persister, j) ); intern( suffixedPropertyAliases[j] ); } return suffixedPropertyAliases; }
/** * The entity instance is already in the session cache */ private void instanceAlreadyLoaded(final ResultSet rs, final int i, final Loadable persister, final EntityKey key, final Object object, final LockMode lockMode, final SessionImplementor session) throws HibernateException, SQLException { if ( !persister.isInstance( object, session.getEntityMode() ) ) { throw new WrongClassException( "loaded object was of wrong class", key.getIdentifier(), persister.getEntityName() ); } if ( LockMode.NONE != lockMode && upgradeLocks() ) { //no point doing this if NONE was requested final boolean isVersionCheckNeeded = persister.isVersioned() && session.getPersistenceContext().getLockMode( object ).lessThan( lockMode ); // we don't need to worry about existing version being uninitialized // because this block isn't called by a re-entrant load (re-entrant // loads _always_ have lock mode NONE) if (isVersionCheckNeeded) { //we only check the version when _upgrading_ lock modes checkVersion( i, persister, key.getIdentifier(), object, rs, session ); //we need to upgrade the lock mode to the mode requested session.getPersistenceContext().setLockMode( object, lockMode ); } } }