normalizedentitypersister.java

用Java实现的23个常用设计模式源代码

			
		}
		catch (SQLException sqle) {
			throw new JDBCException( "could not load by id: " +  MessageHelper.infoString(this, id), sqle );
		}
	}
	
	/**
	 * Do a version check
	 */
	public void lock(Serializable id, Object version, Object object, LockMode lockMode, SessionImplementor session) throws HibernateException {
		
		if ( lockMode!=LockMode.NONE ) {
			
			if ( log.isTraceEnabled() ) {
				log.trace( "Locking entity: " + MessageHelper.infoString(this, id) );
				if ( isVersioned() ) log.trace("Version: " + version);
			}
			
			try {
			
				PreparedStatement st = session.getBatcher().prepareStatement( (String) lockers.get(lockMode) );
				try {
					getIdentifierType().nullSafeSet(st, id, 1, session);
					if ( isVersioned() ) getVersionType().nullSafeSet(st, version, getIdentifierColumnNames().length+1, session);
					
					ResultSet rs = st.executeQuery();
					try {
						if ( !rs.next() ) throw new StaleObjectStateException(getMappedClass(), id);
					}
					finally {
						rs.close();
					}
				}
				catch(SQLException sqle) {
					JDBCExceptionReporter.logExceptions(sqle);
					throw sqle;
				}
				finally {
					session.getBatcher().closeStatement(st);
				}
			}
			catch (SQLException sqle) {
				throw new JDBCException( "could not lock: " +  MessageHelper.infoString(this, id), sqle );
			}
			
		}
		
	}

	public Serializable insert(Object[] fields, Object object, SessionImplementor session) throws HibernateException {
		if ( useDynamicInsert() ) {
			boolean[] notNull = getNotNullInsertableColumns(fields);
			return insert(fields, notNull, generateInsertStrings(true, notNull), object, session);
		}
		else {
			return insert(fields, getPropertyInsertability(), getSQLIdentityInsertStrings(), object, session);
		}
	}
	
	public void insert(Serializable id, Object[] fields, Object object, SessionImplementor session) throws HibernateException {
		if ( useDynamicInsert() ) {
			boolean[] notNull = getNotNullInsertableColumns(fields);
			insert(id, fields, notNull, generateInsertStrings(false, notNull), object, session);
		}
		else {
			insert(id, fields, getPropertyInsertability(), getSQLInsertStrings(), object, session);
		}
	}
	
	/**
	 * Persist an object
	 */
	public void insert(Serializable id, Object[] fields, boolean[] notNull, String[] sql, Object object, SessionImplementor session) throws HibernateException {
		
		if ( log.isTraceEnabled() ) {
			log.trace( "Inserting entity: " + MessageHelper.infoString(this, id) );
			if ( isVersioned() ) log.trace( "Version: " + Versioning.getVersion(fields, this) );
		}
		
		try {
			// Render the SQL query
			final PreparedStatement[] statements = new PreparedStatement[ tableNames.length ];
			try {
				
				for ( int i=0; i<tableNames.length; i++ ) {
					statements[i] = session.getBatcher().prepareStatement( sql[i] );
				}
				
				// Write the values of fields onto the prepared statement - we MUST use the state at the time the
				// insert was issued (cos of foreign key constraints). Not necessarily the object's current state
				
				dehydrate(id, fields, notNull, statements, session);
				
				for ( int i=0; i<tableNames.length; i++ ) statements[i].executeUpdate();
				
			}
			catch(SQLException sqle) {
				JDBCExceptionReporter.logExceptions(sqle);
				throw sqle;
			}
			finally {
				for ( int i=0; i<tableNames.length; i++ ) {
					if ( statements[i]!=null ) session.getBatcher().closeStatement( statements[i] );
				}
			}
		}
		catch (SQLException sqle) {
			throw new JDBCException( "could not insert: " +  MessageHelper.infoString(this, id), sqle );
		}
		
	}
	
	/**
	 * Persist an object, using a natively generated identifier
	 */
	public Serializable insert(Object[] fields, boolean[] notNull, String[] sql, Object object, SessionImplementor session) throws HibernateException {
		
		if ( log.isTraceEnabled() ) {
			log.trace("Inserting entity: " + getClassName() + " (native id)");
			if ( isVersioned() ) log.trace( "Version: " + Versioning.getVersion(fields, this) );
		}
		
		try {
			
			PreparedStatement statement = session.getBatcher().prepareStatement( sql[0] );
			try {
				dehydrate(null, fields, notNull, 0, statement, session);
				statement.executeUpdate();
			}
			catch (SQLException sqle) {
				JDBCExceptionReporter.logExceptions(sqle);
				throw sqle;
			}
			finally {
				session.getBatcher().closeStatement(statement);
			}
			
			// fetch the generated id:
			PreparedStatement idselect = session.getBatcher().prepareStatement( sqlIdentitySelect() );
			final Serializable id;
			try {
				
				ResultSet rs = idselect.executeQuery();
				try {
					if ( !rs.next() ) throw new HibernateException("The database returned no natively generated identity value");
					id = IdentifierGeneratorFactory.get( 
						rs, getIdentifierType(), session, object 
					);
				}
				finally {
					rs.close();
				}
				log.debug("Natively generated identity: " + id);
				
			}
			catch(SQLException sqle) {
				JDBCExceptionReporter.logExceptions(sqle);
				throw sqle;
			}
			finally {
				session.getBatcher().closeStatement(idselect);
			}
			
			for ( int i=1; i<naturalOrderTableNames.length; i++ )  {
				
				statement = session.getBatcher().prepareStatement( sql[i] );
				
				try {
					dehydrate(id, fields, notNull, i, statement, session);
					statement.executeUpdate();
				}
				catch(SQLException sqle) {
					JDBCExceptionReporter.logExceptions(sqle);
					throw sqle;
				}
				finally {
					session.getBatcher().closeStatement(statement);
				}
				
			}
			
			return id;

		}
		catch (SQLException sqle) {
			throw new JDBCException( "could not insert: " +  MessageHelper.infoString(this), sqle );
		}
		
	}
	
	/**
	 * Delete an object
	 */
	public void delete(Serializable id, Object version, Object object, SessionImplementor session) throws HibernateException {
		
		if ( log.isTraceEnabled() ) {
			log.trace( "Deleting entity: " + MessageHelper.infoString(this, id) );
			//if (versioned) log.trace( "Version: " + version );
		}
		
		try {
			final PreparedStatement[] statements = new PreparedStatement[naturalOrderTableNames.length];
			try {
				
				for ( int i=0; i<naturalOrderTableNames.length; i++ ) {
					statements[i] = session.getBatcher().prepareStatement( getSQLDeleteStrings()[i] );
				}
				
				if ( isVersioned() ) getVersionType().nullSafeSet( statements[0], version, getIdentifierColumnNames().length + 1, session );
				
				for ( int i=naturalOrderTableNames.length-1; i>=0; i-- ) {
					
					// Do the key. The key is immutable so we can use the _current_ object state - not necessarily
					// the state at the time the delete was issued
					
					getIdentifierType().nullSafeSet( statements[i], id, 1, session );
					
					check( statements[i].executeUpdate(), id );
					
				}
				
			}
			catch(SQLException sqle) {
				JDBCExceptionReporter.logExceptions(sqle);
				throw sqle;
			}
			finally {
				for ( int i=0; i<naturalOrderTableNames.length; i++ )  {
					if ( statements[i]!=null ) session.getBatcher().closeStatement( statements[i] );
				}
			}
		}
		catch (SQLException sqle) {
			throw new JDBCException( "could not delete: " +  MessageHelper.infoString(this, id), sqle );
		}
	}
	
	/**
	 * Decide which tables need to be updated
	 */
	private boolean[] getTableUpdateNeeded(final int[] dirtyFields) {
		
		if (dirtyFields==null) {
			return propertyHasColumns; // for objects that came in via update()
		}
		else {
			boolean[] tableUpdateNeeded = new boolean[naturalOrderTableNames.length];
			for ( int i=0; i<dirtyFields.length; i++ ) {
				int table = naturalOrderPropertyTables[ dirtyFields[i] ];
				tableUpdateNeeded[table] = tableUpdateNeeded[table] || 
					propertyColumnSpans[ dirtyFields[i] ]>0;
			}
			if ( isVersioned() ) tableUpdateNeeded[0] = true;
			return tableUpdateNeeded;
		}
	}
	
	/**
	 * Update an object
	 */
	public void update(Serializable id, Object[] fields, int[] dirtyFields, Object[] oldFields, Object oldVersion, Object object, SessionImplementor session) throws HibernateException {

		final boolean[] tableUpdateNeeded = getTableUpdateNeeded(dirtyFields);
		
		final String[] updateStrings;
		final boolean[] propsToUpdate;
		if ( useDynamicUpdate() && dirtyFields!=null ) {
			// decide which columns we really need to update
			propsToUpdate = getPropertiesToUpdate(dirtyFields);
			updateStrings = generateUpdateStrings(propsToUpdate);
		}
		else {
			// just update them all
			propsToUpdate = getPropertyUpdateability();
			updateStrings = getSQLUpdateStrings();
		}
		
		update(id, fields, propsToUpdate, tableUpdateNeeded, oldVersion, object, updateStrings, session);
	}
	
	protected void update(Serializable id, Object[] fields, boolean[] includeProperty, boolean[] includeTable, Object oldVersion, Object object, String[] sql, SessionImplementor session) throws HibernateException {
		
		if ( log.isTraceEnabled() ) {
			log.trace( "Updating entity: " + MessageHelper.infoString(this, id) );
			if ( isVersioned() ) log.trace( "Existing version: " + oldVersion + " -> New version: " + fields[ getVersionProperty() ] );
		}
		
		int tables = naturalOrderTableNames.length;
		
		try {
			final PreparedStatement[] statements = new PreparedStatement[tables];
			try {
				
				for ( int i=0; i<tables; i++ ) {
					if ( includeTable[i] ) statements[i] = session.getBatcher().prepareStatement( sql[i] );
				}
				
				int versionParam = dehydrate(id, fields, includeProperty, statements, session);
				
				if ( isVersioned() ) getVersionType().nullSafeSet( statements[0], oldVersion, versionParam, session );
				
				for ( int i=0; i<tables; i++ ) {
					if ( includeTable[i] ) check( statements[i].executeUpdate(), id );
				}
				
			}
			catch(SQLException sqle) {
				JDBCExceptionReporter.logExceptions(sqle);
				throw sqle;
			}
			finally {
				for ( int i=0; i<tables; i++ )  {
					if ( statements[i]!=null ) session.getBatcher().closeStatement( statements[i] );
				}
			}
		}
		catch (SQLException sqle) {
			throw new JDBCException( "could not delete: " +  MessageHelper.infoString(this, id), sqle );
		}
		
	}
	
	//INITIALIZATION:
	
	public NormalizedEntityPersister(PersistentClass model, SessionFactoryImplementor factory) throws HibernateException {
		
		super(model, factory);
		
		// CLASS + TABLE
		
		this.factory = factory;
		Table table = model.getRootTable();
		qualifiedTableName = table.getQualifiedName( getDialect(), factory.getDefaultSchema() );
		
		// DISCRIMINATOR
		
		final Object discriminatorValue;
		if ( model.isPolymorphic() ) {
			discriminatorColumnName = "clazz_";
			try {
				discriminatorType = (DiscriminatorType) Hibernate.INTEGER;
				discriminatorValue = new Integer(0);
				discriminatorSQLString = "0";
			}
			catch (Exception e) {
				throw new MappingException("Could not format discriminator value to SQL string", e );
			}
		}
		else {
			discriminatorColumnName = null;
			discriminatorType = null;
			discriminatorValue = null;
			discriminatorSQLString = null;
		}
		
		if ( optimisticLockMode()!=Versioning.OPTIMISTIC_LOCK_VERSION ) throw new MappingException("optimistic-lock attribute not supported for joined-subclass mappings: " + getClassName() );
		
		//MULTITABLES
		
		ArrayList tables = new ArrayList();
		ArrayList keyColumns = new ArrayList();
		tables.add(qualifiedTableName);
		keyColumns.add( super.getIdentifierColumnNames() );
		
		int idColumnSpan = super.getIdentifierColumnNames().length;
		Iterator titer = model.getTableClosureIterator();
		while ( titer.hasNext() ) {
			Table tab = (Table) titer.next();
			String tabname = tab.getQualifiedName( getDialect(), factory.getDefaultSchema() );
			if ( !tabname.equals(qualifiedTableName) ) {
				tables.add(tabname);
				String[] key = new String[idColumnSpan];
				Iterator kiter = tab.getPrimaryKey().getColumnIterator();
				for ( int k=0; k<idColumnSpan; k++ ) key[k] = ( (Column) kiter.next() ).getQuotedName( getDialect() );
				keyColumns.add(key);
			}
		}
		naturalOrderTableNames = (String[]) tables.toArray(ArrayHelper.EMPTY_STRING_ARRAY);
		naturalOrderTableKeyColumns = (String[][]) keyColumns.toArray( new String[0][] );
		
		ArrayList subtables = new ArrayList();
		keyColumns = new ArrayList();
		subtables.add(qualifiedTableName);
		keyColumns.add( super.getIdentifierColumnNames() );
		titer = model.getSubclassTableClosureIterator();
		while ( titer.hasNext() ) {
			Table tab = (Table) titer.next();
			String tabname = tab.getQualifiedName( getDialect(), factory.getDefaultSchema() );
			if ( !tabname.equals(qualifiedTableName) ) {
				subtables.add(tabname);
				String[] key = new String[idColumnSpan];
				Iterator kiter = tab.getPrimaryKey().getColumnIterator();
				for ( int k=0; k<idColumnSpan; k++ ) key[k] = ( (Column) kiter.next() ).getQuotedName( getDialect() );
				keyColumns.add(key);
			}
		}
		subclassTableNameClosure = (String[]) subtables.toArray(ArrayHelper.EMPTY_STRING_ARRAY);
		subclassTableKeyColumns = (String[][]) keyColumns.toArray( new String[0][] );
		isClassOrSuperclassTable = new boolean[ subclassTableNameClosure.length ];
		for ( int j=0; j<subclassTableNameClosure.length; j++ ) {
			isClassOrSuperclassTable[j] = tables.contains( subclassTableNameClosure[j] );
		}
		
		int len = naturalOrderTableNames.length;
		tableNames = reverse(naturalOrderTableNames);
		tableKeyColumns = reverse(naturalOrderTableKeyColumns);
		reverse(subclassTableNameClosure, len);
		reverse(subclassTableKeyColumns, len);
		
		// PROPERTIES