org.hibernate.loader
Class JoinWalker

java.lang.Object
  extended by org.hibernate.loader.JoinWalker
Direct Known Subclasses:
AbstractEntityJoinWalker, CollectionJoinWalker

public class JoinWalker
extends Object

Walks the metamodel, searching for joins, and collecting together information needed by OuterJoinLoader.

See Also:
OuterJoinLoader

Nested Class Summary
protected static interface JoinWalker.AssociationInitCallback
           
 
Field Summary
protected  String[] aliases
           
protected  List associations
           
protected  int[] collectionOwners
           
protected  CollectionPersister[] collectionPersisters
           
protected  String[] collectionSuffixes
           
protected  LockMode[] lockModeArray
           
protected  LockOptions lockOptions
           
protected  EntityType[] ownerAssociationTypes
           
protected  int[] owners
           
protected  Loadable[] persisters
           
protected  String sql
           
protected  String[] suffixes
           
 
Constructor Summary
protected JoinWalker(SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)
           
 
Method Summary
protected static int countCollectionPersisters(List associations)
          Count the number of instances of Joinable which are actually also instances of PersistentCollection which are being fetched by outer join
protected static int countEntityPersisters(List associations)
          Count the number of instances of Joinable which are actually also instances of Loadable, or are one-to-many associations
protected  String generateRootAlias(String description)
           
protected  String generateTableAlias(int n, PropertyPath path, Joinable joinable)
           
 String[] getAliases()
           
 int[] getCollectionOwners()
           
 CollectionPersister[] getCollectionPersisters()
           
 String[] getCollectionSuffixes()
           
protected  Dialect getDialect()
           
protected  SessionFactoryImplementor getFactory()
           
protected  JoinType getJoinType(AssociationType associationType, FetchMode config, PropertyPath path, String lhsTable, String[] lhsColumns, boolean nullable, int currentDepth, CascadeStyle cascadeStyle)
          Determine the appropriate associationType of join (if any) to use to fetch the given association.
protected  JoinType getJoinType(boolean nullable, int currentDepth)
          Use an inner join if it is a non-null association and this is the "first" join in a series
protected  JoinType getJoinType(OuterJoinLoadable persister, PropertyPath path, int propertyNumber, AssociationType associationType, FetchMode metadataFetchMode, CascadeStyle metadataCascadeStyle, String lhsTable, String[] lhsColumns, boolean nullable, int currentDepth)
          Determine the appropriate type of join (if any) to use to fetch the given association.
 LoadQueryInfluencers getLoadQueryInfluencers()
           
 LockMode[] getLockModeArray()
           
 LockOptions getLockModeOptions()
           
 EntityType[] getOwnerAssociationTypes()
           
 int[] getOwners()
           
 Loadable[] getPersisters()
           
 String getSQLString()
           
 String[] getSuffixes()
           
protected  String getWithClause(PropertyPath path)
           
protected  boolean hasRestriction(PropertyPath path)
           
protected  void initPersisters(List associations, LockMode lockMode)
           
protected  void initPersisters(List associations, LockOptions lockOptions)
           
protected  void initPersisters(List associations, LockOptions lockOptions, JoinWalker.AssociationInitCallback callback)
           
protected  boolean isDuplicateAssociation(String foreignKeyTable, String[] foreignKeyColumns)
          Used to detect circularities in the joined graph, note that this method is side-effecty
protected  boolean isDuplicateAssociation(String lhsTable, String[] lhsColumnNames, AssociationType type)
          Used to detect circularities in the joined graph, note that this method is side-effecty
protected  boolean isJoinable(JoinType joinType, Set visitedAssociationKeys, String lhsTable, String[] lhsColumnNames, AssociationType type, int depth)
          Should we join this association?
protected  boolean isJoinedFetchEnabled(AssociationType type, FetchMode config, CascadeStyle cascadeStyle)
          Override on subclasses to enable or suppress joining of certain association types
protected  boolean isJoinedFetchEnabledInMapping(FetchMode config, AssociationType type)
          Does the mapping, and Hibernate default semantics, specify that this association should be fetched by outer joining
protected  boolean isTooDeep(int currentDepth)
           
protected  boolean isTooManyCollections()
           
protected static String mergeOrderings(String ordering1, String ordering2)
           
protected  JoinFragment mergeOuterJoins(List associations)
          Generate a sequence of LEFT OUTER JOIN clauses for the given associations.
protected static String orderBy(List associations)
          Get the order by string required for collection fetching
protected  String orderBy(List associations, String orderBy)
           
protected  String selectString(List associations)
          Generate a select list of columns containing all properties of the entity classes
 void setAliases(String[] aliases)
           
 void setCollectionOwners(int[] collectionOwners)
           
 void setCollectionPersisters(CollectionPersister[] collectionPersisters)
           
 void setCollectionSuffixes(String[] collectionSuffixes)
           
 void setOwnerAssociationTypes(EntityType[] ownerAssociationType)
           
 void setOwners(int[] owners)
           
 void setPersisters(Loadable[] persisters)
           
 void setSql(String sql)
           
 void setSuffixes(String[] suffixes)
           
protected  void walkCollectionTree(QueryableCollection persister, String alias)
          For a collection role, return a list of associations to be fetched by outerjoin
protected  void walkEntityTree(OuterJoinLoadable persister, String alias)
          Walk the association tree for an entity, adding associations which should be join fetched to the associations inst var.
protected  StringBuilder whereString(String alias, String[] columnNames, int batchSize)
          Render the where condition for a (batch) load by identifier / collection key
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

associations

protected final List associations

suffixes

protected String[] suffixes

collectionSuffixes

protected String[] collectionSuffixes

persisters

protected Loadable[] persisters

owners

protected int[] owners

ownerAssociationTypes

protected EntityType[] ownerAssociationTypes

collectionPersisters

protected CollectionPersister[] collectionPersisters

collectionOwners

protected int[] collectionOwners

aliases

protected String[] aliases

lockOptions

protected LockOptions lockOptions

lockModeArray

protected LockMode[] lockModeArray

sql

protected String sql
Constructor Detail

JoinWalker

protected JoinWalker(SessionFactoryImplementor factory,
                     LoadQueryInfluencers loadQueryInfluencers)
Method Detail

getCollectionSuffixes

public String[] getCollectionSuffixes()

setCollectionSuffixes

public void setCollectionSuffixes(String[] collectionSuffixes)

getLockModeOptions

public LockOptions getLockModeOptions()

getLockModeArray

public LockMode[] getLockModeArray()

getSuffixes

public String[] getSuffixes()

setSuffixes

public void setSuffixes(String[] suffixes)

getAliases

public String[] getAliases()

setAliases

public void setAliases(String[] aliases)

getCollectionOwners

public int[] getCollectionOwners()

setCollectionOwners

public void setCollectionOwners(int[] collectionOwners)

getCollectionPersisters

public CollectionPersister[] getCollectionPersisters()

setCollectionPersisters

public void setCollectionPersisters(CollectionPersister[] collectionPersisters)

getOwnerAssociationTypes

public EntityType[] getOwnerAssociationTypes()

setOwnerAssociationTypes

public void setOwnerAssociationTypes(EntityType[] ownerAssociationType)

getOwners

public int[] getOwners()

setOwners

public void setOwners(int[] owners)

getPersisters

public Loadable[] getPersisters()

setPersisters

public void setPersisters(Loadable[] persisters)

getSQLString

public String getSQLString()

setSql

public void setSql(String sql)

getFactory

protected SessionFactoryImplementor getFactory()

getDialect

protected Dialect getDialect()

getLoadQueryInfluencers

public LoadQueryInfluencers getLoadQueryInfluencers()

hasRestriction

protected boolean hasRestriction(PropertyPath path)

getWithClause

protected String getWithClause(PropertyPath path)

walkEntityTree

protected final void walkEntityTree(OuterJoinLoadable persister,
                                    String alias)
                             throws MappingException
Walk the association tree for an entity, adding associations which should be join fetched to the associations inst var. This form is the entry point into the walking for a given entity, starting the recursive calls into walkEntityTree(org.hibernate.persister.entity.OuterJoinLoadable, String, PropertyPath ,int).

Parameters:
persister - The persister representing the entity to be walked.
alias - The (root) alias to use for this entity/persister.
Throws:
MappingException - ???

walkCollectionTree

protected final void walkCollectionTree(QueryableCollection persister,
                                        String alias)
                                 throws MappingException
For a collection role, return a list of associations to be fetched by outerjoin

Throws:
MappingException

getJoinType

protected JoinType getJoinType(OuterJoinLoadable persister,
                               PropertyPath path,
                               int propertyNumber,
                               AssociationType associationType,
                               FetchMode metadataFetchMode,
                               CascadeStyle metadataCascadeStyle,
                               String lhsTable,
                               String[] lhsColumns,
                               boolean nullable,
                               int currentDepth)
                        throws MappingException
Determine the appropriate type of join (if any) to use to fetch the given association.

Parameters:
persister - The owner of the association.
path - The path to the association
propertyNumber - The property number representing the association.
associationType - The association type.
metadataFetchMode - The metadata-defined fetch mode.
metadataCascadeStyle - The metadata-defined cascade style.
lhsTable - The owner table
lhsColumns - The owner join columns
nullable - Is the association nullable.
currentDepth - Current join depth
Returns:
type of join to use (JoinType.INNER_JOIN, JoinType.LEFT_OUTER_JOIN, or -1 to indicate no joining.
Throws:
MappingException - ??

getJoinType

protected JoinType getJoinType(AssociationType associationType,
                               FetchMode config,
                               PropertyPath path,
                               String lhsTable,
                               String[] lhsColumns,
                               boolean nullable,
                               int currentDepth,
                               CascadeStyle cascadeStyle)
                        throws MappingException
Determine the appropriate associationType of join (if any) to use to fetch the given association.

Parameters:
associationType - The association associationType.
config - The metadata-defined fetch mode.
path - The path to the association
lhsTable - The owner table
lhsColumns - The owner join columns
nullable - Is the association nullable.
currentDepth - Current join depth
cascadeStyle - The metadata-defined cascade style.
Returns:
type of join to use (JoinType.INNER_JOIN, JoinType.LEFT_OUTER_JOIN, or -1 to indicate no joining.
Throws:
MappingException - ??

getJoinType

protected JoinType getJoinType(boolean nullable,
                               int currentDepth)
Use an inner join if it is a non-null association and this is the "first" join in a series


isTooDeep

protected boolean isTooDeep(int currentDepth)

isTooManyCollections

protected boolean isTooManyCollections()

isJoinedFetchEnabledInMapping

protected boolean isJoinedFetchEnabledInMapping(FetchMode config,
                                                AssociationType type)
                                         throws MappingException
Does the mapping, and Hibernate default semantics, specify that this association should be fetched by outer joining

Throws:
MappingException

isJoinedFetchEnabled

protected boolean isJoinedFetchEnabled(AssociationType type,
                                       FetchMode config,
                                       CascadeStyle cascadeStyle)
Override on subclasses to enable or suppress joining of certain association types


generateTableAlias

protected String generateTableAlias(int n,
                                    PropertyPath path,
                                    Joinable joinable)

generateRootAlias

protected String generateRootAlias(String description)

isDuplicateAssociation

protected boolean isDuplicateAssociation(String foreignKeyTable,
                                         String[] foreignKeyColumns)
Used to detect circularities in the joined graph, note that this method is side-effecty


isDuplicateAssociation

protected boolean isDuplicateAssociation(String lhsTable,
                                         String[] lhsColumnNames,
                                         AssociationType type)
Used to detect circularities in the joined graph, note that this method is side-effecty


isJoinable

protected boolean isJoinable(JoinType joinType,
                             Set visitedAssociationKeys,
                             String lhsTable,
                             String[] lhsColumnNames,
                             AssociationType type,
                             int depth)
Should we join this association?


orderBy

protected String orderBy(List associations,
                         String orderBy)

mergeOrderings

protected static String mergeOrderings(String ordering1,
                                       String ordering2)

mergeOuterJoins

protected final JoinFragment mergeOuterJoins(List associations)
                                      throws MappingException
Generate a sequence of LEFT OUTER JOIN clauses for the given associations.

Throws:
MappingException

countEntityPersisters

protected static final int countEntityPersisters(List associations)
                                          throws MappingException
Count the number of instances of Joinable which are actually also instances of Loadable, or are one-to-many associations

Throws:
MappingException

countCollectionPersisters

protected static final int countCollectionPersisters(List associations)
                                              throws MappingException
Count the number of instances of Joinable which are actually also instances of PersistentCollection which are being fetched by outer join

Throws:
MappingException

orderBy

protected static final String orderBy(List associations)
                               throws MappingException
Get the order by string required for collection fetching

Throws:
MappingException

whereString

protected StringBuilder whereString(String alias,
                                    String[] columnNames,
                                    int batchSize)
Render the where condition for a (batch) load by identifier / collection key


initPersisters

protected void initPersisters(List associations,
                              LockMode lockMode)
                       throws MappingException
Throws:
MappingException

initPersisters

protected void initPersisters(List associations,
                              LockOptions lockOptions)
                       throws MappingException
Throws:
MappingException

initPersisters

protected void initPersisters(List associations,
                              LockOptions lockOptions,
                              JoinWalker.AssociationInitCallback callback)
                       throws MappingException
Throws:
MappingException

selectString

protected final String selectString(List associations)
                             throws MappingException
Generate a select list of columns containing all properties of the entity classes

Throws:
MappingException


Copyright © 2001-2013 Red Hat, Inc. All Rights Reserved.