Code example for Mapping

Methods: getIdentifierTypegetReferencedPropertyType

0
			PreparedStatement st, 
			Object value, 
			int index, 
			SessionImplementor session) throws HibernateException, SQLException { 
		getIdentifierOrUniqueKeyType( session.getFactory() ) 
				.nullSafeSet( st, getIdentifier( value, session ), index, session ); 
	} 
 
	public ForeignKeyDirection getForeignKeyDirection() { 
		return ForeignKeyDirection.FOREIGN_KEY_FROM_PARENT; 
	} 
 
	public Object hydrate( 
			ResultSet rs, 
			String[] names, 
			SessionImplementor session, 
			Object owner) throws HibernateException, SQLException { 
		// return the (fully resolved) identifier value, but do not resolve 
		// to the actual referenced entity instance 
		// NOTE: the owner of the association is not really the owner of the id! 
		Serializable id = (Serializable) getIdentifierOrUniqueKeyType( session.getFactory() ) 
				.nullSafeGet( rs, names, session, null ); 
		scheduleBatchLoadIfNeeded( id, session ); 
		return id; 
	} 
 
	/** 
	 * Register the entity as batch loadable, if enabled 
	 */ 
	@SuppressWarnings({ "JavaDoc" }) 
	private void scheduleBatchLoadIfNeeded(Serializable id, SessionImplementor session) throws MappingException { 
		//cannot batch fetch by unique key (property-ref associations) 
		if ( uniqueKeyPropertyName == null && id != null ) { 
			final EntityPersister persister = session.getFactory().getEntityPersister( getAssociatedEntityName() ); 
			final EntityKey entityKey = session.generateEntityKey( id, persister ); 
			if ( !session.getPersistenceContext().containsEntity( entityKey ) ) { 
				session.getPersistenceContext().getBatchFetchQueue().addBatchLoadableEntityKey( entityKey ); 
			} 
		} 
	} 
	 
	public boolean useLHSPrimaryKey() { 
		return false; 
	} 
 
	public boolean isModified( 
			Object old, 
			Object current, 
			boolean[] checkable, 
			SessionImplementor session) throws HibernateException { 
		if ( current == null ) { 
			return old!=null; 
		} 
		if ( old == null ) { 
			// we already know current is not null... 
			return true; 
		} 
		// the ids are fully resolved, so compare them with isDirty(), not isModified() 
		return getIdentifierOrUniqueKeyType( session.getFactory() ) 
				.isDirty( old, getIdentifier( current, session ), session ); 
	} 
 
	public Serializable disassemble( 
			Object value, 
			SessionImplementor session, 
			Object owner) throws HibernateException { 
 
		if ( isNotEmbedded( session ) ) { 
			return getIdentifierType( session ).disassemble( value, session, owner ); 
		} 
		 
		if ( value == null ) { 
			return null; 
		} 
		else { 
			// cache the actual id of the object, not the value of the 
			// property-ref, which might not be initialized 
			Object id = ForeignKeys.getEntityIdentifierIfNotUnsaved( 
					getAssociatedEntityName(), 
					value, 
					session 
			); 
			if ( id == null ) { 
				throw new AssertionFailure( 
						"cannot cache a reference to an object with a null id: " +  
						getAssociatedEntityName() 
				); 
			} 
			return getIdentifierType( session ).disassemble( id, session, owner ); 
		} 
	} 
 
	public Object assemble( 
			Serializable oid, 
			SessionImplementor session, 
			Object owner) throws HibernateException { 
		 
		//TODO: currently broken for unique-key references (does not detect 
		//      change to unique key property of the associated object) 
		 
		Serializable id = assembleId( oid, session ); 
 
		if ( isNotEmbedded( session ) ) { 
			return id; 
		} 
		 
		if ( id == null ) { 
			return null; 
		} 
		else { 
			return resolveIdentifier( id, session ); 
		} 
	} 
 
	private Serializable assembleId(Serializable oid, SessionImplementor session) { 
		//the owner of the association is not the owner of the id 
		return ( Serializable ) getIdentifierType( session ).assemble( oid, session, null ); 
	} 
 
	public void beforeAssemble(Serializable oid, SessionImplementor session) { 
		scheduleBatchLoadIfNeeded( assembleId( oid, session ), session ); 
	} 
	 
	public boolean[] toColumnNullness(Object value, Mapping mapping) { 
		boolean[] result = new boolean[ getColumnSpan( mapping ) ]; 
		if ( value != null ) { 
			Arrays.fill( result, true ); 
		} 
		return result; 
	} 
	 
	public boolean isDirty( 
			Object old, 
			Object current, 
			SessionImplementor session) throws HibernateException { 
		if ( isSame( old, current ) ) { 
			return false; 
		} 
		Object oldid = getIdentifier( old, session ); 
		Object newid = getIdentifier( current, session ); 
		return getIdentifierType( session ).isDirty( oldid, newid, session ); 
	} 
 
	public boolean isDirty( 
			Object old, 
			Object current, 
			boolean[] checkable, 
			SessionImplementor session) throws HibernateException { 
		if ( isAlwaysDirtyChecked() ) { 
			return isDirty( old, current, session ); 
		} 
		else { 
			if ( isSame( old, current ) ) { 
				return false; 
			} 
			Object oldid = getIdentifier( old, session ); 
			Object newid = getIdentifier( current, session ); 
			return getIdentifierType( session ).isDirty( oldid, newid, checkable, session ); 
		} 
		 
	} 
 
}