public JoinSequence(SessionFactoryImplementor factory) 
{
		this.factory = factory;
}

 public JoinSequence addCondition(String condition) 
{
		if ( condition.trim().length() != 0 ) {
			if ( !condition.startsWith( " and " ) ) conditions.append( " and " );
			conditions.append( condition );
		}
		return this;
}

 public JoinSequence addCondition(String alias,
    String[] columns,
    String condition) 
{
		for ( int i = 0; i <  columns.length; i++ ) {
			conditions.append( " and " )
					.append( alias )
					.append( '.' )
					.append( columns[i] )
					.append( condition );
		}
		return this;
}

 public JoinSequence addJoin(AssociationType associationType,
    String alias,
    int joinType,
    String[] referencingKey) throws MappingException 
{
		joins.add( new Join( associationType, alias, joinType, referencingKey ) );
		return this;
}

 public JoinSequence copy() 
{
		JoinSequence copy = new JoinSequence( factory );
		copy.joins.addAll( this.joins );
		copy.useThetaStyle = this.useThetaStyle;
		copy.rootAlias = this.rootAlias;
		copy.rootJoinable = this.rootJoinable;
		copy.selector = this.selector;
		copy.next = this.next == null ? null : this.next.copy();
		copy.isFromPart = this.isFromPart;
		copy.conditions.append( this.conditions.toString() );
		return copy;
}

 public JoinSequence getFromPart() 
{
		JoinSequence fromPart = new JoinSequence( factory );
		fromPart.joins.addAll( this.joins );
		fromPart.useThetaStyle = this.useThetaStyle;
		fromPart.rootAlias = this.rootAlias;
		fromPart.rootJoinable = this.rootJoinable;
		fromPart.selector = this.selector;
		fromPart.next = this.next == null ? null : this.next.getFromPart();
		fromPart.isFromPart = true;
		return fromPart;
}

 public int getJoinCount() 
{
		return joins.size();
}

 public boolean isThetaStyle() 
{
		return useThetaStyle;
}

 public JoinSequence setNext(JoinSequence next) 
{
		this.next = next;
		return this;
}

 public JoinSequence setRoot(Joinable joinable,
    String alias) 
{
		this.rootAlias = alias;
		this.rootJoinable = joinable;
		return this;
}

 public JoinSequence setSelector(Selector s) 
{
		this.selector = s;
		return this;
}

 public JoinSequence setUseThetaStyle(boolean useThetaStyle) 
{
		this.useThetaStyle = useThetaStyle;
		return this;
}

 public JoinFragment toJoinFragment() throws MappingException 
{
		return toJoinFragment( CollectionHelper.EMPTY_MAP, true );
}

 public JoinFragment toJoinFragment(Map enabledFilters,
    boolean includeExtraJoins) throws MappingException 
{
		return toJoinFragment( enabledFilters, includeExtraJoins, null, null );
}

 public JoinFragment toJoinFragment(Map enabledFilters,
    boolean includeExtraJoins,
    String withClauseFragment,
    String withClauseJoinAlias) throws MappingException 
{
		QueryJoinFragment joinFragment = new QueryJoinFragment( factory.getDialect(), useThetaStyle );
		if ( rootJoinable != null ) {
			joinFragment.addCrossJoin( rootJoinable.getTableName(), rootAlias );
			String filterCondition = rootJoinable.filterFragment( rootAlias, enabledFilters );
			// JoinProcessor needs to know if the where clause fragment came from a dynamic filter or not so it
			// can put the where clause fragment in the right place in the SQL AST.   'hasFilterCondition' keeps track
			// of that fact.
			joinFragment.setHasFilterCondition( joinFragment.addCondition( filterCondition ) );
			if (includeExtraJoins) { //TODO: not quite sure about the full implications of this!
				addExtraJoins( joinFragment, rootAlias, rootJoinable, true );
			}
		}
		Joinable last = rootJoinable;
		for ( int i = 0; i <  joins.size(); i++ ) {
			Join join = ( Join ) joins.get( i );
			String on = join.getAssociationType().getOnCondition( join.getAlias(), factory, enabledFilters );
			String condition = null;
			if ( last != null &&
			        isManyToManyRoot( last ) &&
			        ( ( QueryableCollection ) last ).getElementType() == join.getAssociationType() ) {
				// the current join represents the join between a many-to-many association table
				// and its "target" table.  Here we need to apply any additional filters
				// defined specifically on the many-to-many
				String manyToManyFilter = ( ( QueryableCollection ) last )
				        .getManyToManyFilterFragment( join.getAlias(), enabledFilters );
				condition = "".equals( manyToManyFilter )
						? on
						: "".equals( on )
								? manyToManyFilter
								: on + " and " + manyToManyFilter;
			}
			else {
				condition = on;
			}
			if ( withClauseFragment != null ) {
				if ( join.getAlias().equals( withClauseJoinAlias ) ) {
					condition += " and " + withClauseFragment;
				}
			}
			joinFragment.addJoin(
			        join.getJoinable().getTableName(),
					join.getAlias(),
					join.getLHSColumns(),
					JoinHelper.getRHSColumnNames( join.getAssociationType(), factory ),
					join.joinType,
					condition
			);
			if (includeExtraJoins) { //TODO: not quite sure about the full implications of this!
				addExtraJoins( joinFragment, join.getAlias(), join.getJoinable(), join.joinType == JoinFragment.INNER_JOIN );
			}
			last = join.getJoinable();
		}
		if ( next != null ) {
			joinFragment.addFragment( next.toJoinFragment( enabledFilters, includeExtraJoins ) );
		}
		joinFragment.addCondition( conditions.toString() );
		if ( isFromPart ) joinFragment.clearWherePart();
		return joinFragment;
}

 public String toString() 
{
		StringBuffer buf = new StringBuffer();
		buf.append( "JoinSequence{" );
		if ( rootJoinable != null ) {
			buf.append( rootJoinable )
					.append( '[' )
					.append( rootAlias )
					.append( ']' );
		}
		for ( int i = 0; i <  joins.size(); i++ ) {
			buf.append( "- >" ).append( joins.get( i ) );
		}
		return buf.append( '}' ).toString();
}