@Override public Object[] getCachedDatabaseSnapshot(EntityKey key) { final Object snapshot = entitySnapshotsByKey.get( key ); if ( snapshot == NO_ROW ) { throw new IllegalStateException( "persistence context reported no row snapshot for " + MessageHelper.infoString( key.getEntityName(), key.getIdentifier() ) ); } return (Object[]) snapshot; }
@Override public EntityKey generateEntityKey(Serializable id, EntityPersister persister) { return new EntityKey( id, persister ); }
i, persister, key.getIdentifier(), session ); final EntityDataAccess cache = persister.getCacheAccessStrategy(); final Object ck = cache.generateCacheKey( key.getIdentifier(), persister, session.getFactory(), if ( optionalObjectKey != null && key.equals( optionalObjectKey ) ) { object = session.instantiate( instanceClass, key.getIdentifier() );
/** * Intended for test usage. Really has no use-case in Hibernate proper. */ public boolean containsEntityKey(EntityKey key) { if ( key.isBatchLoadable() ) { LinkedHashSet<EntityKey> set = batchLoadableEntityKeys.get( key.getEntityName()); if ( set != null ) { return set.contains( key ); } } return false; }
public SubselectOneToManyLoader( QueryableCollection persister, String subquery, Collection entityKeys, QueryParameters queryParameters, Map<String, int[]> namedParameterLocMap, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers) throws MappingException { super( persister, 1, subquery, factory, loadQueryInfluencers ); keys = new Serializable[ entityKeys.size() ]; Iterator iter = entityKeys.iterator(); int i=0; while ( iter.hasNext() ) { keys[i++] = ( (EntityKey) iter.next() ).getIdentifier(); } this.namedParameters = queryParameters.getNamedParameters(); this.types = queryParameters.getFilteredPositionalParameterTypes(); this.values = queryParameters.getFilteredPositionalParameterValues(); this.namedParameterLocMap = namedParameterLocMap; }
@Override public boolean equals(Object o) { if ( this == o ) { return true; } if ( o == null || getClass() != o.getClass() ) { return false; } final AssociationKey that = (AssociationKey) o; return ownerKey.equals( that.ownerKey ) && propertyName.equals( that.propertyName ); }
public void toString(Iterable<Map.Entry<EntityKey, Object>> entitiesByEntityKey) throws HibernateException { if ( !LOG.isDebugEnabled() || !entitiesByEntityKey.iterator().hasNext() ) { return; } LOG.debug( "Listing entities:" ); int i = 0; for ( Map.Entry<EntityKey, Object> entityKeyAndEntity : entitiesByEntityKey ) { if ( i++ > 20 ) { LOG.debug( "More......" ); break; } LOG.debug( toString( entityKeyAndEntity.getKey().getEntityName(), entityKeyAndEntity.getValue() ) ); } }
public static String toLoggableString(EntityKey entityKey) { return toLoggableString( StringHelper.collapse( entityKey.getEntityName() ), entityKey.getKeyValue() ); }
/** * Construct a unique identifier for an entity class instance. * <p/> * NOTE : This signature has changed to accommodate both entity mode and multi-tenancy, both of which relate to * the Session to which this key belongs. To help minimize the impact of these changes in the future, the * {@link SessionImplementor#generateEntityKey} method was added to hide the session-specific changes. * * @param id The entity id * @param persister The entity persister */ public EntityKey(Serializable id, EntityPersister persister) { this.persister = persister; if ( id == null ) { throw new AssertionFailure( "null identifier" ); } this.identifier = id; this.hashCode = generateHashCode(); }
@Override public int hashCode() { int result = ownerKey.hashCode(); result = 31 * result + propertyName.hashCode(); return result; } }
rtn.entitiesByKey.put( EntityKey.deserialize( ois, sfi ), ois.readObject() ); ); for ( int i = 0; i < count; i++ ) { final EntityKey ek = EntityKey.deserialize( ois, sfi ); final Object proxy = ois.readObject(); if ( proxy instanceof HibernateProxy ) { rtn.entitySnapshotsByKey.put( EntityKey.deserialize( ois, sfi ), ois.readObject() ); rtn.nullifiableEntityKeys.add( EntityKey.deserialize( ois, sfi ) );
/** * After evicting or deleting or loading an entity, we don't * need to batch fetch it anymore, remove it from the queue * if necessary */ public void removeBatchLoadableEntityKey(EntityKey key) { if ( key.isBatchLoadable() ) batchLoadableEntityKeys.remove(key); }
public SubselectCollectionLoader( QueryableCollection persister, String subquery, Collection entityKeys, QueryParameters queryParameters, Map<String, int[]> namedParameterLocMap, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers) throws MappingException { super( persister, 1, subquery, factory, loadQueryInfluencers ); keys = new Serializable[ entityKeys.size() ]; Iterator iter = entityKeys.iterator(); int i=0; while ( iter.hasNext() ) { keys[i++] = ( (EntityKey) iter.next() ).getIdentifier(); } this.namedParameters = queryParameters.getNamedParameters(); this.types = queryParameters.getFilteredPositionalParameterTypes(); this.values = queryParameters.getFilteredPositionalParameterValues(); this.namedParameterLocMap = namedParameterLocMap; }
/** * After evicting or deleting or loading an entity, we don't * need to batch fetch it anymore, remove it from the queue * if necessary */ public void removeBatchLoadableEntityKey(EntityKey key) { if ( key.isBatchLoadable() ) { LinkedHashSet<EntityKey> set = batchLoadableEntityKeys.get( key.getEntityName()); if (set != null) { set.remove(key); } } }
private boolean isCurrentRowForSameEntity( final EntityKey keyToRead, final int persisterIndex, final ResultSet resultSet, final SharedSessionContractImplementor session) throws SQLException { EntityKey currentRowKey = getKeyFromResultSet( persisterIndex, getEntityPersisters()[persisterIndex], null, resultSet, session ); return keyToRead.equals( currentRowKey ); }
final EntityPersister persister = event.getSession() .getFactory() .getEntityPersister( keyToLoad.getEntityName() ); if ( !persister.isInstance( old ) ) { LOG.debug(
/** * Used to reconstruct an EntityKey during deserialization. * * @param identifier The identifier value * @param rootEntityName The root entity name * @param entityName The specific entity name * @param identifierType The type of the identifier value * @param batchLoadable Whether represented entity is eligible for batch loading * @param factory The session factory * @param tenantId The entity's tenant id (from the session that loaded it). */ private EntityKey( Serializable identifier, String rootEntityName, String entityName, Type identifierType, boolean batchLoadable, SessionFactoryImplementor factory, String tenantId) { this.identifier = identifier; this.rootEntityName = rootEntityName; this.entityName = entityName; this.identifierType = identifierType; this.isBatchLoadable = batchLoadable; this.factory = factory; this.tenantId = tenantId; this.hashCode = generateHashCode(); }
@Override public int hashCode() { int result = ownerKey.hashCode(); result = 31 * result + propertyName.hashCode(); return result; } }
while ( itr.hasNext() ) { Map.Entry entry = ( Map.Entry ) itr.next(); ( ( EntityKey ) entry.getKey() ).serialize( oos ); oos.writeObject( entry.getValue() ); while ( itr.hasNext() ) { Map.Entry entry = ( Map.Entry ) itr.next(); ( (EntityKey) entry.getKey() ).serialize( oos ); oos.writeObject( entry.getValue() ); while ( itr.hasNext() ) { Map.Entry entry = ( Map.Entry ) itr.next(); ( ( EntityKey ) entry.getKey() ).serialize( oos ); oos.writeObject( entry.getValue() ); if ( tracing ) LOG.trace("Starting serialization of [" + nullifiableEntityKeys.size() + "] nullifiableEntityKey entries"); for ( EntityKey entry : nullifiableEntityKeys ) { entry.serialize( oos );