Java Joinable.isCollection方法代码示例

import org.hibernate.persister.entity.Joinable; //导入方法依赖的package包/类
public String selectFragment(
        Joinable rhs,
        String rhsAlias,
        String lhsAlias,
        String entitySuffix,
        String collectionSuffix,
        boolean includeCollectionColumns) {
	// we need to determine the best way to know that two joinables
	// represent a single many-to-many...
	if ( rhs != null && isManyToMany() && !rhs.isCollection() ) {
		AssociationType elementType = ( ( AssociationType ) getElementType() );
		if ( rhs.equals( elementType.getAssociatedJoinable( getFactory() ) ) ) {
			return manyToManySelectFragment( rhs, rhsAlias, lhsAlias, collectionSuffix );
		}
	}
	return includeCollectionColumns ? selectFragment( lhsAlias, collectionSuffix ) : "";
}
 

import org.hibernate.persister.entity.Joinable; //导入方法依赖的package包/类
@Override
public AssociationKey getAssociationKey() {
	final AssociationType type = getType();

	if ( type.isAnyType() ) {
		return new AssociationKey(
				JoinHelper.getLHSTableName( type, attributeNumber(), (OuterJoinLoadable) getSource() ),
				JoinHelper.getLHSColumnNames(
						type,
						attributeNumber(),
						0,
						(OuterJoinLoadable) getSource(),
						sessionFactory()
				)
		);
	}

	final Joinable joinable = type.getAssociatedJoinable( sessionFactory() );

	if ( type.getForeignKeyDirection() == ForeignKeyDirection.FOREIGN_KEY_FROM_PARENT ) {
		final String lhsTableName;
		final String[] lhsColumnNames;

		if ( joinable.isCollection() ) {
			final QueryableCollection collectionPersister = (QueryableCollection) joinable;
			lhsTableName = collectionPersister.getTableName();
			lhsColumnNames = collectionPersister.getElementColumnNames();
		}
		else {
			final OuterJoinLoadable entityPersister = (OuterJoinLoadable) source();
			lhsTableName = getLHSTableName( type, attributeNumber(), entityPersister );
			lhsColumnNames = getLHSColumnNames( type, attributeNumber(), entityPersister, sessionFactory() );
		}
		return new AssociationKey( lhsTableName, lhsColumnNames );
	}
	else {
		return new AssociationKey( joinable.getTableName(), getRHSColumnNames( type, sessionFactory() ) );
	}
}
 

import org.hibernate.persister.entity.Joinable; //导入方法依赖的package包/类
@SuppressWarnings("SimplifiableIfStatement")
private boolean isManyToManyRoot(Joinable joinable) {
	if ( joinable != null && joinable.isCollection() ) {
		return ( (QueryableCollection) joinable ).isManyToMany();
	}
	return false;
}
 

import org.hibernate.persister.entity.Joinable; //导入方法依赖的package包/类
private boolean isManyToManyRoot(Joinable joinable) {
	if ( joinable != null && joinable.isCollection() ) {
		QueryableCollection persister = ( QueryableCollection ) joinable;
		return persister.isManyToMany();
	}
	return false;
}
 

import org.hibernate.persister.entity.Joinable; //导入方法依赖的package包/类
/**
	 * Add on association (one-to-one, many-to-one, or a collection) to a list 
	 * of associations to be fetched by outerjoin 
	 */
	private void addAssociationToJoinTree(
			final AssociationType type,
			final String[] aliasedLhsColumns,
			final String alias,
			final PropertyPath path,
			final int currentDepth,
			final JoinType joinType) throws MappingException {

		Joinable joinable = type.getAssociatedJoinable( getFactory() );

		// important to generate alias based on size of association collection
		// *before* adding this join to that collection
		String subalias = generateTableAlias( associations.size() + 1, path, joinable );

		// NOTE : it should be fine to continue to pass only filters below
		// (instead of LoadQueryInfluencers) since "from that point on" we
		// only need to worry about restrictions (and not say adding more
		// joins)
		OuterJoinableAssociation assoc = new OuterJoinableAssociation(
				path,
				type, 
				alias, 
				aliasedLhsColumns, 
				subalias, 
				joinType, 
				getWithClause(path),
				hasRestriction( path ),
				getFactory(),
				loadQueryInfluencers.getEnabledFilters()
		);
		assoc.validateJoin( path.getFullPath() );
		associations.add( assoc );

		int nextDepth = currentDepth + 1;
//		path = "";
		if ( !joinable.isCollection() ) {
			if (joinable instanceof OuterJoinLoadable) {
				walkEntityTree(
					(OuterJoinLoadable) joinable, 
					subalias,
					path, 
					nextDepth
				);
			}
		}
		else {
			if (joinable instanceof QueryableCollection) {
				walkCollectionTree(
					(QueryableCollection) joinable, 
					subalias, 
					path, 
					nextDepth
				);
			}
		}

	}
 

import org.hibernate.persister.entity.Joinable; //导入方法依赖的package包/类
@Override
protected String generateTableAlias(int n, PropertyPath path, Joinable joinable) {
	// TODO: deal with side-effects (changes to includeInResultRowList, userAliasList, resultTypeList)!!!

	// for collection-of-entity, we are called twice for given "path"
	// once for the collection Joinable, once for the entity Joinable.
	// the second call will/must "consume" the alias + perform side effects according to consumesEntityAlias()
	// for collection-of-other, however, there is only one call 
	// it must "consume" the alias + perform side effects, despite what consumeEntityAlias() return says
	// 
	// note: the logic for adding to the userAliasList is still strictly based on consumesEntityAlias return value
	boolean checkForSqlAlias = joinable.consumesEntityAlias();

	if ( !checkForSqlAlias && joinable.isCollection() ) {
		// is it a collection-of-other (component or value) ?
		CollectionPersister collectionPersister = (CollectionPersister)joinable;
		Type elementType = collectionPersister.getElementType();
		if ( elementType.isComponentType() || !elementType.isEntityType() ) {
			checkForSqlAlias = true;
			}
	}

	String sqlAlias = null;

	if ( checkForSqlAlias ) {
		final Criteria subcriteria = translator.getCriteria( path.getFullPath() );
		sqlAlias = subcriteria==null ? null : translator.getSQLAlias(subcriteria);
		
		if (joinable.consumesEntityAlias() && ! translator.hasProjection()) {
			includeInResultRowList.add( subcriteria != null && subcriteria.getAlias() != null );
			if (sqlAlias!=null) {
				if ( subcriteria.getAlias() != null ) {
					userAliasList.add( subcriteria.getAlias() );
					resultTypeList.add( translator.getResultType( subcriteria ) );
				}
			}
		}
	}

	if (sqlAlias == null) {
		sqlAlias = super.generateTableAlias( n + translator.getSQLAliasCount(), path, joinable );
	}

	return sqlAlias;
}
 

import org.hibernate.persister.entity.Joinable; //导入方法依赖的package包/类
/**
	 * Returns the {@link PropertyIdentifier} for the given property path.
	 *
	 * In passing, it creates all the necessary aliases for embedded/associations.
	 *
	 * @param entityType the type of the entity
	 * @param propertyPath the path to the property without aliases
	 * @return the {@link PropertyIdentifier}
	 */
	public PropertyIdentifier getPropertyIdentifier(String entityType, List<String> propertyPath) {
		// we analyze the property path to find all the associations/embedded which are in the way and create proper
		// aliases for them
		String entityAlias = findAliasForType( entityType );

		String propertyEntityType = entityType;
		String propertyAlias = entityAlias;
		String propertyName;

		List<String> currentPropertyPath = new ArrayList<>();
		List<String> lastAssociationPath = Collections.emptyList();
		OgmEntityPersister currentPersister = getPersister( entityType );

		int requiredDepth = propertyPath.size();
		boolean isLastElementAssociation = false;
		int depth = 1;
		for ( String property : propertyPath ) {
			currentPropertyPath.add( property );
			Type currentPropertyType = getPropertyType( entityType, currentPropertyPath );

			// determine if the current property path is still part of requiredPropertyMatch
			boolean optionalMatch = depth > requiredDepth;

			if ( currentPropertyType.isAssociationType() ) {
				AssociationType associationPropertyType = (AssociationType) currentPropertyType;
				Joinable associatedJoinable = associationPropertyType.getAssociatedJoinable( getSessionFactory() );
				if ( associatedJoinable.isCollection()
						&& ( (OgmCollectionPersister) associatedJoinable ).getType().isComponentType() ) {
					// we have a collection of embedded
					throw new NotYetImplementedException();
//					propertyAlias = aliasResolver.createAliasForEmbedded( entityAlias, currentPropertyPath, optionalMatch );
				}
				else {
					propertyEntityType = associationPropertyType.getAssociatedEntityName( getSessionFactory() );
					currentPersister = getPersister( propertyEntityType );
					String targetNodeType = currentPersister.getEntityKeyMetadata().getTable();

					throw new NotYetImplementedException();
//					propertyAlias = aliasResolver.createAliasForAssociation( entityAlias, currentPropertyPath, targetNodeType, optionalMatch );
//					lastAssociationPath = new ArrayList<>( currentPropertyPath );
//					isLastElementAssociation = true;
				}
			}
			else if ( currentPropertyType.isComponentType()
					&& !isIdProperty( currentPersister, propertyPath.subList( lastAssociationPath.size(), propertyPath.size() ) ) ) {
				// we are in the embedded case and the embedded is not the id of the entity (the id is stored as normal
				// properties)
				throw new NotYetImplementedException();
//				propertyAlias = aliasResolver.createAliasForEmbedded( entityAlias, currentPropertyPath, optionalMatch );
			}
			else {
				isLastElementAssociation = false;
			}
			depth++;
		}
		if ( isLastElementAssociation ) {
			// even the last element is an association, we need to find a suitable identifier property
			propertyName = getSessionFactory().getEntityPersister( propertyEntityType ).getIdentifierPropertyName();
		}
		else {
			// the last element is a property so we can build the test with this property
			propertyName = getColumnName( propertyEntityType, propertyPath.subList( lastAssociationPath.size(), propertyPath.size() ) );
		}
		return new PropertyIdentifier( propertyAlias, propertyName );
	}
 

import org.hibernate.persister.entity.Joinable; //导入方法依赖的package包/类
/**
 * Add on association (one-to-one, many-to-one, or a collection) to a list 
 * of associations to be fetched by outerjoin 
 */
private void addAssociationToJoinTree(
	final AssociationType type,
	final String[] aliasedLhsColumns,
	final String alias,
	final String path,
	final int currentDepth,
	final int joinType)
throws MappingException {

	Joinable joinable = type.getAssociatedJoinable( getFactory() );

	String subalias = generateTableAlias(
			associations.size()+1, //before adding to collection!
			path, 
			joinable
		);

	OuterJoinableAssociation assoc = new OuterJoinableAssociation(
			type, 
			alias, 
			aliasedLhsColumns, 
			subalias, 
			joinType, 
			getFactory(), 
			enabledFilters
		);
	assoc.validateJoin(path);
	associations.add(assoc);

	int nextDepth = currentDepth+1;
	if ( !joinable.isCollection() ) {
		if (joinable instanceof OuterJoinLoadable) {
			walkEntityTree(
				(OuterJoinLoadable) joinable, 
				subalias,
				path, 
				nextDepth
			);
		}
	}
	else {
		if (joinable instanceof QueryableCollection) {
			walkCollectionTree(
				(QueryableCollection) joinable, 
				subalias, 
				path, 
				nextDepth
			);
		}
	}

}