import org.hibernate.QueryException; //导入依赖的package包/类
protected QueryableCollection getQueryableCollection(
		String entityName,
		String propertyName,
		SessionFactoryImplementor factory) throws HibernateException {
	final PropertyMapping ownerMapping = (PropertyMapping) factory.getEntityPersister( entityName );
	final Type type = ownerMapping.toType( propertyName );
	if ( !type.isCollectionType() ) {
		throw new MappingException(
				"Property path [" + entityName + "." + propertyName + "] does not reference a collection"
		);
	}

	final String role = ( (CollectionType) type ).getRole();
	try {
		return (QueryableCollection) factory.getCollectionPersister( role );
	}
	catch ( ClassCastException cce ) {
		throw new QueryException( "collection role is not queryable: " + role );
	}
	catch ( Exception e ) {
		throw new QueryException( "collection role not found: " + role );
	}
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
private void createAssociationPathCriteriaMap() {
	final Iterator<CriteriaImpl.Subcriteria> iter = rootCriteria.iterateSubcriteria();
	while ( iter.hasNext() ) {
		CriteriaImpl.Subcriteria crit = iter.next();
		String wholeAssociationPath = getWholeAssociationPath( crit );
		Object old = associationPathCriteriaMap.put( wholeAssociationPath, crit );
		if ( old != null ) {
			throw new QueryException( "duplicate association path: " + wholeAssociationPath );
		}
		JoinType joinType = crit.getJoinType();
		old = associationPathJoinTypesMap.put( wholeAssociationPath, joinType );
		if ( old != null ) {
			// TODO : not so sure this is needed...
			throw new QueryException( "duplicate association path: " + wholeAssociationPath );
		}
		if ( crit.getWithClause() != null ) {
			this.withClauseMap.put( wholeAssociationPath, crit.getWithClause() );
		}
	}
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
private void validateLhs(FromReferenceNode lhs) {
	// make sure the lhs is "assignable"...
	if ( !lhs.isResolved() ) {
		throw new UnsupportedOperationException( "cannot validate assignablity of unresolved node" );
	}

	if ( lhs.getDataType().isCollectionType() ) {
		throw new QueryException( "collections not assignable in update statements" );
	}
	else if ( lhs.getDataType().isComponentType() ) {
		throw new QueryException( "Components currently not assignable in update statements" );
	}
	else if ( lhs.getDataType().isEntityType() ) {
		// currently allowed...
	}

	// TODO : why aren't these the same?
	if ( lhs.getImpliedJoin() != null || lhs.getFromElement().isImplied() ) {
		throw new QueryException( "Implied join paths are not assignable in update statements" );
	}
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
public void end(QueryTranslatorImpl q) throws QueryException {
	ignoreInitialJoin = false;

	Type propertyType = getPropertyType();
	if ( propertyType != null && propertyType.isCollectionType() ) {
		collectionRole = ( ( CollectionType ) propertyType ).getRole();
		collectionName = q.createNameForCollection( collectionRole );
		prepareForIndex( q );
	}
	else {
		columns = currentColumns();
		setType();
	}

	//important!!
	continuation = false;

}
 

import org.hibernate.QueryException; //导入依赖的package包/类
public String[] toColumns(String alias, String propertyName) throws QueryException {
	//TODO: *two* hashmap lookups here is one too many...
	String[] columns = (String[]) columnsByPropertyPath.get(propertyName);
	if ( columns == null ) {
		throw propertyException( propertyName );
	}
	String[] formulaTemplates = (String[]) formulaTemplatesByPropertyPath.get(propertyName);
	String[] columnReaderTemplates = (String[]) columnReaderTemplatesByPropertyPath.get(propertyName);
	String[] result = new String[columns.length];
	for ( int i=0; i<columns.length; i++ ) {
		if ( columnReaderTemplates[i]==null ) {
			result[i] = StringHelper.replace( formulaTemplates[i], Template.TEMPLATE, alias );
		}
		else {
			result[i] = StringHelper.replace( columnReaderTemplates[i], Template.TEMPLATE, alias );
		}
	}
	return result;
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
/**
 * Coordinates the efforts to perform a scroll across all the included query translators.
 *
 * @param queryParameters The query parameters
 * @param session The session
 *
 * @return The query result iterator
 *
 * @throws HibernateException Indicates a problem performing the query
 */
public ScrollableResults performScroll(
		QueryParameters queryParameters,
		SessionImplementor session) throws HibernateException {
	if ( TRACE_ENABLED ) {
		LOG.tracev( "Iterate: {0}", getSourceQuery() );
		queryParameters.traceParameters( session.getFactory() );
	}
	if ( translators.length != 1 ) {
		throw new QueryException( "implicit polymorphism not supported for scroll() queries" );
	}
	if ( queryParameters.getRowSelection().definesLimits() && translators[0].containsCollectionFetches() ) {
		throw new QueryException( "firstResult/maxResults not supported in conjunction with scroll() of a query containing collection fetches" );
	}

	return translators[0].scroll( queryParameters, session );
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
@Override
public String render(Type firstArgumentType, List args, SessionFactoryImplementor factory) throws QueryException {
	final boolean threeArgs = args.size() > 2;
	final Object pattern = args.get( 0 );
	final Object string = args.get( 1 );
	final Object start = threeArgs ? args.get( 2 ) : null;

	final StringBuilder buf = new StringBuilder();
	if (threeArgs) {
		buf.append( '(' );
	}
	buf.append( "position(" ).append( pattern ).append( " in " );
	if (threeArgs) {
		buf.append( "substring(");
	}
	buf.append( string );
	if (threeArgs) {
		buf.append( ", " ).append( start ).append( ')' );
	}
	buf.append( ')' );
	if (threeArgs) {
		buf.append( '+' ).append( start ).append( "-1)" );
	}
	return buf.toString();
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
private void createAssociationPathCriteriaMap() {
	final Iterator<CustomCriteriaImpl.Subcriteria> iter = rootCriteria.iterateSubcriteria();
	while ( iter.hasNext() ) {
		CustomCriteriaImpl.Subcriteria crit = iter.next();
		String wholeAssociationPath = getWholeAssociationPath( crit );
		Object old = associationPathCriteriaMap.put( wholeAssociationPath, crit );
		if ( old != null ) {
			throw new QueryException( "duplicate association path: " + wholeAssociationPath );
		}
		JoinType joinType = crit.getJoinType();
		old = associationPathJoinTypesMap.put( wholeAssociationPath, joinType );
		if ( old != null ) {
			// TODO : not so sure this is needed...
			throw new QueryException( "duplicate association path: " + wholeAssociationPath );
		}
		if ( crit.getWithClause() != null ) {
			this.withClauseMap.put( wholeAssociationPath, crit.getWithClause() );
		}
	}
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
private String getElementName(PathExpressionParser.CollectionElement element, QueryTranslatorImpl q) throws QueryException {
	String name;
	if ( element.isOneToMany ) {
		name = element.alias;
	}
	else {
		Type type = element.elementType;
		if ( type.isEntityType() ) { //ie. a many-to-many
			String entityName = ( ( EntityType ) type ).getAssociatedEntityName();
			name = pathExpressionParser.continueFromManyToMany( entityName, element.elementColumns, q );
		}
		else {
			throw new QueryException( "illegally dereferenced collection element" );
		}
	}
	return name;
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
@Override
public String render(Type columnType, List args, SessionFactoryImplementor factory) throws QueryException {
	final boolean threeArgs = args.size() > 2;
	final Object pattern = args.get( 0 );
	final Object string = args.get( 1 );
	final Object start = threeArgs ? args.get( 2 ) : null;

	final StringBuilder buf = new StringBuilder();
	buf.append( "charindex(" ).append( pattern ).append( ", " );
	if (threeArgs) {
		buf.append( "right(" );
	}
	buf.append( string );
	if (threeArgs) {
		buf.append( ", char_length(" ).append( string ).append( ")-(" ).append( start ).append( "-1))" );
	}
	buf.append( ')' );
	return buf.toString();
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
@Override
public String render(Type columnType, List args, SessionFactoryImplementor factory) throws QueryException {
	if ( args.size()!=2 ) {
		throw new QueryException( "cast() requires two arguments; found : " + args.size() );
	}
	final String type = (String) args.get( 1 );
	final int[] sqlTypeCodes = factory.getTypeResolver().heuristicType( type ).sqlTypes( factory );
	if ( sqlTypeCodes.length!=1 ) {
		throw new QueryException("invalid Hibernate type for cast()");
	}
	String sqlType = factory.getDialect().getCastTypeName( sqlTypeCodes[0] );
	if ( sqlType == null ) {
		//TODO: never reached, since getExplicitHibernateTypeName() actually throws an exception!
		sqlType = type;
	}
	return "cast(" + args.get( 0 ) + " as " + sqlType + ')';
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
@Override
public Type getReturnType(Type columnType, Mapping mapping) throws QueryException {
	int[] sqlTypes;
	try {
		sqlTypes = columnType.sqlTypes( mapping );
	}
	catch ( MappingException me ) {
		throw new QueryException( me );
	}

	if ( sqlTypes.length != 1 ) {
		throw new QueryException( "multi-column type in avg()" );
	}

	final int sqlType = sqlTypes[0];
	if ( sqlType == Types.INTEGER || sqlType == Types.BIGINT || sqlType == Types.TINYINT ) {
		return StandardBasicTypes.FLOAT;
	}
	else {
		return columnType;
	}
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
/**
 * Locate the collection persister by the collection role, requiring that
 * such a persister exist.
 *
 * @param role The collection role name.
 *
 * @return The defined CollectionPersister for this collection role.
 *
 * @throws QueryException Indicates that the collection persister could not be found.
 */
public QueryableCollection requireQueryableCollection(String role) throws QueryException {
	try {
		QueryableCollection queryableCollection = (QueryableCollection) sfi.getCollectionPersister( role );
		if ( queryableCollection != null ) {
			collectionPropertyMappingByRole.put( role, new CollectionPropertyMapping( queryableCollection ) );
		}
		return queryableCollection;
	}
	catch ( ClassCastException cce ) {
		throw new QueryException( "collection role is not queryable: " + role );
	}
	catch ( Exception e ) {
		throw new QueryException( "collection role not found: " + role );
	}
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
/**
 * Returns the locations of all occurrences of the named parameter.
 */
public int[] getNamedParameterLocations(String name) throws QueryException {
	Object o = namedParameters.get( name );
	if ( o == null ) {
		throw new QueryException(
				QueryTranslator.ERROR_NAMED_PARAMETER_DOES_NOT_APPEAR + name,
				queryTranslatorImpl.getQueryString()
		);
	}
	if ( o instanceof Integer ) {
		return new int[] {(Integer) o};
	}
	else {
		return ArrayHelper.toIntArray( (ArrayList) o );
	}
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
public void validateTypes(SelectClause selectClause) throws QueryException {
	Type[] selectTypes = selectClause.getQueryReturnTypes();
	if ( selectTypes.length + selectClause.getTotalParameterCount() != types.length ) {
		throw new QueryException( "number of select types did not match those for insert" );
	}

	int parameterCount = 0; 
	for ( int i = 0; i < types.length; i++ ) {
		if( selectClause.getParameterPositions().contains(i) ) {
			parameterCount++;
		}
		else if ( !areCompatible( types[i], selectTypes[i - parameterCount] ) ) {
			throw new QueryException(
			        "insertion type [" + types[i] + "] and selection type [" +
			        selectTypes[i - parameterCount] + "] at position " + i + " are not compatible"
			);
		}
	}

	// otherwise, everything ok.
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
PropertyMapping getPropertyMapping(String name) throws QueryException {
	PropertyMapping decorator = getDecoratedPropertyMapping( name );
	if ( decorator != null ) return decorator;

	String type = getType( name );
	if ( type == null ) {
		String role = getRole( name );
		if ( role == null ) {
			throw new QueryException( "alias not found: " + name );
		}
		return getCollectionPersister( role ); //.getElementPropertyMapping();
	}
	else {
		Queryable persister = getEntityPersister( type );
		if ( persister == null ) throw new QueryException( "persistent class not found: " + type );
		return persister;
	}
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
void setCollectionToFetch(String role, String name, String ownerName, String entityName)
		throws QueryException {
	fetchName = name;
	collectionPersister = getCollectionPersister( role );
	collectionOwnerName = ownerName;
	if ( collectionPersister.getElementType().isEntityType() ) {
		addEntityToFetch( entityName );
	}
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
/**
 * Wrap the incoming tuples in a call to our configured constructor.
 */
@Override
public Object transformTuple(Object[] tuple, String[] aliases) {
	try {
		return constructor.newInstance( tuple );
	}
	catch ( Exception e ) {
		throw new QueryException( 
				"could not instantiate class [" + constructor.getDeclaringClass().getName() + "] from tuple",
				e
		);
	}
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
private void createAliasCriteriaMap() {
	aliasCriteriaMap.put( rootCriteria.getAlias(), rootCriteria );
	Iterator<CriteriaImpl.Subcriteria> iter = rootCriteria.iterateSubcriteria();
	while ( iter.hasNext() ) {
		Criteria subcriteria = iter.next();
		if ( subcriteria.getAlias() != null ) {
			Object old = aliasCriteriaMap.put( subcriteria.getAlias(), subcriteria );
			if ( old != null ) {
				throw new QueryException( "duplicate alias: " + subcriteria.getAlias() );
			}
		}
	}
}
 

import org.hibernate.QueryException; //导入依赖的package包/类
@Override
public void betweenFunctionArguments() {
	if ( startedType ) {
		throw new QueryException( "CAST function should only have 2 arguments" );
	}
	startedType = true;
}