JoinWalker (Hibernate Core Aggregator 3.6.10.Final API)

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.

Author:

Gavin King, Jon Lipsky

See Also:
OuterJoinLoader

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static interface JoinWalker.AssociationInitCallback

Nested Classes
Modifier and Type	Class and Description
`protected static interface`	`JoinWalker.AssociationInitCallback`

Field Summary

Fields
Modifier and Type	Field and Description
`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

Constructors
Modifier Constructor and Description

protected JoinWalker(SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)

Constructors
Modifier	Constructor and Description
`protected`	`JoinWalker(SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers)`

Method Summary

Methods
Modifier and Type	Method and Description
`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 int`	`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 int`	`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 int`	`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(int 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 StringBuffer`	`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 int 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 (JoinFragment.INNER_JOIN, JoinFragment.LEFT_OUTER_JOIN, or -1 to indicate no joining.

Throws:

MappingException - ??

getJoinType
```
protected int 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 (JoinFragment.INNER_JOIN, JoinFragment.LEFT_OUTER_JOIN, or -1 to indicate no joining.

Throws:

MappingException - ??

getJoinType
```
protected int 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(int 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 StringBuffer 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

Class JoinWalker

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

associations

suffixes

collectionSuffixes

persisters

owners

ownerAssociationTypes

collectionPersisters

collectionOwners

aliases

lockOptions

lockModeArray

sql

Constructor Detail

JoinWalker

Method Detail

getCollectionSuffixes

setCollectionSuffixes

getLockModeOptions

getLockModeArray

getSuffixes

setSuffixes

getAliases

setAliases

getCollectionOwners

setCollectionOwners

getCollectionPersisters

setCollectionPersisters

getOwnerAssociationTypes

setOwnerAssociationTypes

getOwners

setOwners

getPersisters

setPersisters

getSQLString

setSql

getFactory

getDialect

getLoadQueryInfluencers

hasRestriction

getWithClause

walkEntityTree

walkCollectionTree

getJoinType

getJoinType

getJoinType

isTooDeep

isTooManyCollections

isJoinedFetchEnabledInMapping

isJoinedFetchEnabled

generateTableAlias

generateRootAlias

isDuplicateAssociation

isDuplicateAssociation

isJoinable

orderBy

mergeOrderings

mergeOuterJoins

countEntityPersisters

countCollectionPersisters

orderBy

whereString

initPersisters

initPersisters

initPersisters

selectString