entitypersister.java

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

					boolean[] includeOldField = optimisticLockMode()==Versioning.OPTIMISTIC_LOCK_ALL ?
						getPropertyUpdateability() :
						includeProperty;
					for (int j=0; j<getHydrateSpan(); j++) {
						if ( includeOldField[j] && oldFields[j]!=null ) {
							getPropertyTypes()[j].nullSafeSet( statement, oldFields[j], index, session );
							index += propertyColumnSpans[j];
						}
					}
					
					check( statement.executeUpdate(), id );
				}
				else {
					session.getBatcher().addToBatch(1);
				}
				
			}
			catch (SQLException sqle) {
				if ( !isVersioned() ) {
					session.getBatcher().abortBatch(sqle);
				}
				else {
					JDBCExceptionReporter.logExceptions(sqle);
				}
				throw sqle;
			}
			finally {
				if ( isVersioned() ) session.getBatcher().closeStatement(statement);
			}
		}
		catch (SQLException sqle) {
			throw new JDBCException( "could not update: " +  MessageHelper.infoString(this, id), sqle );
		}
		
	}
	
	//INITIALIZATION:
	
	public EntityPersister(PersistentClass model, SessionFactoryImplementor factory) throws HibernateException {
		
		super(model, factory);
		
		// CLASS + TABLE
		
		Class mappedClass = model.getMappedClass();
		this.factory = factory;
		Table table = model.getRootTable();
		qualifiedTableName = table.getQualifiedName( getDialect(), factory.getDefaultSchema() );
		tableNames = new String[] { qualifiedTableName };
		
		//detect mapping errors:
		HashSet distinctColumns = new HashSet();

		// DISCRIMINATOR
		
		final Object discriminatorValue;
		if ( model.isPolymorphic() ) {
			Value d = model.getDiscriminator();
			if (d==null) throw new MappingException("discriminator mapping required for polymorphic persistence");
			forceDiscriminator = model.isForceDiscriminator();
			Column column = ( (Column) d.getColumnIterator().next() );
			discriminatorColumnName = column.getQuotedName( getDialect() );
			discriminatorAlias = column.getAlias();
			discriminatorType = model.getDiscriminator().getType();
			if ( model.isDiscriminatorValueNull() ) {
				discriminatorValue = NULL_DISCRIMINATOR;
				discriminatorSQLValue = InFragment.NULL;
			}
			else if ( model.isDiscriminatorValueNotNull() ) {
				discriminatorValue = NOT_NULL_DISCRIMINATOR;
				discriminatorSQLValue = InFragment.NOT_NULL;
			}
			else {
				try {
					DiscriminatorType dtype = (DiscriminatorType) discriminatorType;
					discriminatorValue = dtype.stringToObject( model.getDiscriminatorValue() );
					discriminatorSQLValue = dtype.objectToSQLString(discriminatorValue);
				}
				catch (ClassCastException cce) {
					throw new MappingException("Illegal discriminator type: " + discriminatorType.getName() );
				}
				catch (Exception e) {
					throw new MappingException("Could not format discriminator value to SQL string", e);
				}
				distinctColumns.add(discriminatorColumnName); //don't do this check for the case of null/not null discriminator values
			}
		}
		else {
			forceDiscriminator = false;
			discriminatorColumnName = null;
			discriminatorAlias = null;
			discriminatorType = null;
			discriminatorValue = null;
			discriminatorSQLValue = null;
		}
		
		// PROPERTIES

		checkColumnDuplication( distinctColumns, model.getKey().getColumnIterator() );
		
		int hydrateSpan = getHydrateSpan();
		propertyColumnNames = new String[hydrateSpan][];
		propertyColumnAliases = new String[hydrateSpan][];
		propertyColumnSpans = new int[hydrateSpan];
		propertyFormulaTemplates = new String[hydrateSpan];
		HashSet thisClassProperties = new HashSet();
		
		Iterator iter = model.getPropertyClosureIterator();
		int i=0;
		
		boolean foundColumn = false;
		while( iter.hasNext() ) {
			Property prop = (Property) iter.next();
			thisClassProperties.add(prop);
			
			if ( prop.isFormula() ) {
				propertyColumnAliases[i] = new String[] { prop.getFormula().getAlias() };
				propertyColumnSpans[i] = 1;
				propertyFormulaTemplates[i] = prop.getFormula().getTemplate( getDialect() );
			}
			else {
				int span = prop.getColumnSpan();
				propertyColumnSpans[i] = span;
				String[] colNames = new String[span];
				String[] colAliases = new String[span];
				Iterator colIter = prop.getColumnIterator();
				int j=0;
				while ( colIter.hasNext() ) {
					Column col = (Column) colIter.next();
					colAliases[j] = col.getAlias();
					colNames[j] = col.getQuotedName( getDialect() );
					j++;
					if ( prop.isUpdateable() ) foundColumn=true;
				}
				propertyColumnNames[i] = colNames;
				propertyColumnAliases[i] = colAliases;
			}
			
			//initPropertyPaths(prop, StringHelper.EMPTY_STRING, factory);
			i++;

			//columns must be unique accross all subclasses
			if ( prop.isUpdateable() || prop.isInsertable() ) {
				checkColumnDuplication( distinctColumns, prop.getColumnIterator() );
			}

		}
		
		hasUpdateableColumns = foundColumn;
		
		ArrayList columns = new ArrayList();
		ArrayList aliases = new ArrayList();
		ArrayList formulas = new ArrayList();
		ArrayList formulaAliases = new ArrayList();
		ArrayList formulaTemplates = new ArrayList();
		ArrayList types = new ArrayList();
		ArrayList names = new ArrayList();
		ArrayList propColumns = new ArrayList();
		ArrayList joinedFetchesList = new ArrayList();
		ArrayList definedBySubclass = new ArrayList();
		
		iter = model.getSubclassPropertyClosureIterator();
		while ( iter.hasNext() ) {
			Property prop = (Property) iter.next();
			names.add( prop.getName() );
			definedBySubclass.add( new Boolean( !thisClassProperties.contains(prop) ) );
			types.add( prop.getType() );
			
			if ( prop.isFormula() ) {
				formulas.add( prop.getFormula().getFormula() );
				formulaTemplates.add( prop.getFormula().getTemplate( getDialect() ) );
				propColumns.add(ArrayHelper.EMPTY_STRING_ARRAY);
				formulaAliases.add( prop.getFormula().getAlias() );
			}
			else {
				Iterator colIter = prop.getColumnIterator();
				String[] cols = new String[ prop.getColumnSpan() ];
				int l=0;
				while ( colIter.hasNext() ) {
					Column col = (Column) colIter.next();
					columns.add( col.getQuotedName( getDialect() ) );
					aliases.add( col.getAlias() );
					cols[l++] = col.getQuotedName( getDialect() );
				}
				propColumns.add(cols);
			}
			joinedFetchesList.add( new Integer(
				prop.getValue().getOuterJoinFetchSetting()
			) );			
		}
		subclassColumnClosure = (String[]) columns.toArray(ArrayHelper.EMPTY_STRING_ARRAY);
		subclassFormulaClosure = (String[]) formulas.toArray(ArrayHelper.EMPTY_STRING_ARRAY);
		subclassFormulaTemplateClosure = (String[]) formulaTemplates.toArray(ArrayHelper.EMPTY_STRING_ARRAY);
		subclassPropertyTypeClosure = (Type[]) types.toArray(ArrayHelper.EMPTY_TYPE_ARRAY);
		subclassColumnAliasClosure = (String[]) aliases.toArray(ArrayHelper.EMPTY_STRING_ARRAY);
		subclassFormulaAliasClosure = (String[]) formulaAliases.toArray(ArrayHelper.EMPTY_STRING_ARRAY);
		subclassPropertyNameClosure = (String[]) names.toArray(ArrayHelper.EMPTY_STRING_ARRAY);
		subclassPropertyColumnNameClosure = (String[][]) propColumns.toArray( new String[ propColumns.size() ][] );
		
		subclassPropertyEnableJoinedFetch = new int[ joinedFetchesList.size() ];
		iter = joinedFetchesList.iterator();
		int j=0;
		while ( iter.hasNext() ) subclassPropertyEnableJoinedFetch[j++] = ( (Integer) iter.next() ).intValue();
		propertyDefinedOnSubclass = new boolean[ definedBySubclass.size() ];
		iter = definedBySubclass.iterator();
		j=0;
		while ( iter.hasNext() ) propertyDefinedOnSubclass[j++] = ( (Boolean) iter.next() ).booleanValue();
		
		sqlDeleteString = generateDeleteString();
		sqlInsertString = generateInsertString( false, getPropertyInsertability() );
		sqlIdentityInsertString = isIdentifierAssignedByInsert() ? 
			generateInsertString( true, getPropertyInsertability() ) : 
			null;
		sqlUpdateString = generateUpdateString( getPropertyUpdateability() );
		sqlConcreteSelectString = generateConcreteSelectString( getPropertyUpdateability() );
		sqlVersionSelectString = generateSelectVersionString();
		
		String lockString = generateLockString();
		lockers.put(LockMode.READ, lockString);
		String lockExclusiveString = getDialect().supportsForUpdate() ? 
			lockString + " for update" : 
			lockString;
		lockers.put(LockMode.UPGRADE, lockExclusiveString);
		String lockExclusiveNowaitString = getDialect().supportsForUpdateNowait() ? 
			lockString + " for update nowait" : 
			lockExclusiveString;
		lockers.put(LockMode.UPGRADE_NOWAIT, lockExclusiveNowaitString);
		
		
		int subclassSpan = model.getSubclassSpan() + 1;
		subclassClosure = new Class[subclassSpan];
		subclassClosure[0] = mappedClass;
		if ( model.isPolymorphic() ) {
			subclassesByDiscriminatorValue.put(discriminatorValue, mappedClass);
		}
		
		// SUBCLASSES
		if ( model.isPolymorphic() ) {
			iter = model.getSubclassIterator();
			int k=1;
			while ( iter.hasNext() ) {
				Subclass sc = (Subclass) iter.next();
				subclassClosure[k++] = sc.getMappedClass();
				if ( sc.isDiscriminatorValueNull() ) {
					subclassesByDiscriminatorValue.put( NULL_DISCRIMINATOR, sc.getMappedClass() );
				}
				else if ( sc.isDiscriminatorValueNotNull() ) {
					subclassesByDiscriminatorValue.put( NOT_NULL_DISCRIMINATOR, sc.getMappedClass() );
				}
				else {
					try {
						DiscriminatorType dtype = (DiscriminatorType) discriminatorType;
						subclassesByDiscriminatorValue.put(
							dtype.stringToObject( sc.getDiscriminatorValue() ),
							sc.getMappedClass()
						);
					}
					catch (ClassCastException cce) {
						throw new MappingException("Illegal discriminator type: " + discriminatorType.getName() );
					}
					catch (Exception e) {
						throw new MappingException("Error parsing discriminator value", e);
					}
				}
			}
		}
		
		initSubclassPropertyAliasesMap(model);
		
	}
	
	public String fromTableFragment(String name) {
		return getTableName() + ' '  + name;
	}

	public String queryWhereFragment(String name, boolean innerJoin, boolean includeSubclasses) throws MappingException {
		
		if ( innerJoin && ( forceDiscriminator || isInherited() ) ) {
			InFragment frag = new InFragment()
				.setColumn( name, getDiscriminatorColumnName() );
			Class[] subclasses = getSubclassClosure();
			for ( int i=0; i<subclasses.length; i++ ) {
				frag.addValue(
					( (Queryable) factory.getPersister( subclasses[i] ) ).getDiscriminatorSQLValue()
				);
			}
			StringBuffer buf = new StringBuffer(50)
				.append(" and ")
				.append( frag.toFragmentString() );
			if ( hasWhere() ) buf
				.append(" and ")
				.append( getSQLWhereString(name) );
			return buf.toString();
		}
		else {
			return hasWhere() ? 
				" and " + getSQLWhereString(name) : 
				StringHelper.EMPTY_STRING;
		}
		
	}
	
	public String[] toColumns(String name, int i) {
		return StringHelper.qualify( name, subclassPropertyColumnNameClosure[i] );
	}
	
	public String getSubclassPropertyTableName(int i) {
		return qualifiedTableName;
	}
	
	public String propertySelectFragment(String name, String suffix) {
		
		SelectFragment frag = new SelectFragment()
			.setSuffix(suffix);
		if ( hasSubclasses() ) frag.addColumn( name, getDiscriminatorColumnName(),  getDiscriminatorAlias() );
		return frag.addColumns(name, subclassColumnClosure, subclassColumnAliasClosure)
			.addFormulas(name, subclassFormulaTemplateClosure, subclassFormulaAliasClosure)
			.toFragmentString();
	}
	
	public String fromJoinFragment(String alias, boolean innerJoin, boolean includeSubclasses) {
		return StringHelper.EMPTY_STRING;
	}

	public String whereJoinFragment(String alias, boolean innerJoin, boolean includeSubclasses) {
		return StringHelper.EMPTY_STRING;
	}

	protected String[] getActualPropertyColumnNames(int i) {
		return propertyColumnNames[i];
	}
	
	protected String getFormulaTemplate(int i) {
		return propertyFormulaTemplates[i];
	}
	
	protected String getConcreteSelectString() {
		return sqlConcreteSelectString;
	}

}