org.hibernate.engine.internal

Class JoinSequence

java.lang.Object

org.hibernate.engine.internal.JoinSequence

public class JoinSequence
extends Object

A sequence of JoinSequence.Join delegates to make it "easier" to work with joins. The "easier" part is obviously subjective ;)

Additionally JoinSequence is a directed graph of other JoinSequence instances, as represented by the next (setNext(JoinSequence)) pointer.

Author:

Gavin King, Steve Ebersole

See Also:

JoinFragment

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	JoinSequence.Join Represents a join
static interface	JoinSequence.Selector A subclass join selector

Constructor Summary

Constructors

Constructor and Description
JoinSequence(SessionFactoryImplementor factory) Constructs a JoinSequence

Method Summary

Modifier and Type	Method and Description
JoinSequence	addCondition(String condition) Add a condition to this sequence.
JoinSequence	addCondition(String alias, String[] columns, String condition) Add a condition to this sequence.
JoinSequence	addJoin(AssociationType associationType, String alias, JoinType joinType, String[] referencingKey) Add a join to this sequence
void	applyTreatAsDeclarations(Set<String> treatAsDeclarations)
JoinSequence	copy() Create a full, although shallow, copy.
JoinSequence.Join	getFirstJoin()
JoinSequence	getFromPart() Retrieve a JoinSequence that represents just the FROM clause parts
protected Set<String>	getTreatAsDeclarations()
protected boolean	isIncluded(String alias)
boolean	isThetaStyle()
JoinSequence	setNext(JoinSequence next) Sets the next join sequence
JoinSequence	setRoot(Joinable joinable, String alias) Set the root of this JoinSequence.
JoinSequence	setSelector(JoinSequence.Selector selector) Set the Selector to use to determine how subclass joins should be applied.
JoinSequence	setUseThetaStyle(boolean useThetaStyle) Should this JoinSequence use theta-style joining (both a FROM and WHERE component) in the rendered SQL?
JoinFragment	toJoinFragment() Generate a JoinFragment
JoinFragment	toJoinFragment(Map enabledFilters, boolean includeAllSubclassJoins) Generate a JoinFragment
JoinFragment	toJoinFragment(Map enabledFilters, boolean includeAllSubclassJoins, String withClauseFragment, String withClauseJoinAlias) Generate a JoinFragment
String	toString()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

JoinSequence

public JoinSequence(SessionFactoryImplementor factory)

Constructs a JoinSequence

Parameters:

factory - The SessionFactory

Method Detail

getFromPart

public JoinSequence getFromPart()

Retrieve a JoinSequence that represents just the FROM clause parts

Returns:

The JoinSequence that represents just the FROM clause parts

applyTreatAsDeclarations

public void applyTreatAsDeclarations(Set<String> treatAsDeclarations)

getTreatAsDeclarations

protected Set<String> getTreatAsDeclarations()

copy

public JoinSequence copy()

Create a full, although shallow, copy.

Returns:

The copy

addJoin

public JoinSequence addJoin(AssociationType associationType,
                            String alias,
                            JoinType joinType,
                            String[] referencingKey)
                     throws MappingException

Add a join to this sequence

Parameters:

associationType - The type of the association representing the join

alias - The RHS alias for the join

joinType - The type of join (INNER, etc)

referencingKey - The LHS columns for the join condition

Returns:

The Join memento

Throws:

MappingException - Generally indicates a problem resolving the associationType to a Joinable

toJoinFragment

public JoinFragment toJoinFragment()
                            throws MappingException

Generate a JoinFragment

Returns:

The JoinFragment

Throws:

MappingException - Indicates a problem access the provided metadata, or incorrect metadata

toJoinFragment

public JoinFragment toJoinFragment(Map enabledFilters,
                                   boolean includeAllSubclassJoins)
                            throws MappingException

Generate a JoinFragment

Parameters:

enabledFilters - The filters associated with the originating session to properly define join conditions

includeAllSubclassJoins - Should all subclass joins be added to the rendered JoinFragment?

Returns:

The JoinFragment

Throws:

MappingException - Indicates a problem access the provided metadata, or incorrect metadata

toJoinFragment

public JoinFragment toJoinFragment(Map enabledFilters,
                                   boolean includeAllSubclassJoins,
                                   String withClauseFragment,
                                   String withClauseJoinAlias)
                            throws MappingException

Generate a JoinFragment

Parameters:

enabledFilters - The filters associated with the originating session to properly define join conditions

includeAllSubclassJoins - Should all subclass joins be added to the rendered JoinFragment?

withClauseFragment - The with clause (which represents additional join restrictions) fragment

withClauseJoinAlias - The

Returns:

The JoinFragment

Throws:

MappingException - Indicates a problem access the provided metadata, or incorrect metadata

isIncluded

protected boolean isIncluded(String alias)

addCondition

public JoinSequence addCondition(String condition)

Add a condition to this sequence.

Parameters:

condition - The condition

Returns:

this, for method chaining

addCondition

public JoinSequence addCondition(String alias,
                                 String[] columns,
                                 String condition)

Add a condition to this sequence. Typical usage here might be:

     addCondition( "a", {"c1", "c2"}, "?" )
 

to represent:

     "... a.c1 = ? and a.c2 = ? ..."
 

Parameters:

alias - The alias to apply to the columns

columns - The columns to add checks for

condition - The conditions to check against the columns

Returns:

this, for method chaining

setRoot

public JoinSequence setRoot(Joinable joinable,
                            String alias)

Set the root of this JoinSequence. In SQL terms, this would be the driving table.

Parameters:

joinable - The entity/collection that is the root of this JoinSequence

alias - The alias associated with that joinable.

Returns:

this, for method chaining

setNext

public JoinSequence setNext(JoinSequence next)

Sets the next join sequence

Parameters:

next - The next JoinSequence in the directed graph

Returns:

this, for method chaining

setSelector

public JoinSequence setSelector(JoinSequence.Selector selector)

Set the Selector to use to determine how subclass joins should be applied.

Parameters:

selector - The selector to apply

Returns:

this, for method chaining

setUseThetaStyle

public JoinSequence setUseThetaStyle(boolean useThetaStyle)

Should this JoinSequence use theta-style joining (both a FROM and WHERE component) in the rendered SQL?

Parameters:

useThetaStyle - true indicates that theta-style joins should be used.

Returns:

this, for method chaining

isThetaStyle

public boolean isThetaStyle()

getFirstJoin

public JoinSequence.Join getFirstJoin()

toString

public String toString()

Overrides:

toString in class Object