## org.hibernate.loader
Class JoinWalker

    java.lang.Object
      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-2012 Red Hat, Inc. All Rights Reserved.