Open Source Repository

Home /hibernate/hibernate-3.2.7.ga | Repository Home


org/hibernate/hql/ast/util/JoinProcessor.java
// $Id: JoinProcessor.java 15240 2008-10-01 19:32:11Z [email protected] $
package org.hibernate.hql.ast.util;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Collection;

import org.hibernate.AssertionFailure;
import org.hibernate.param.DynamicFilterParameterSpecification;
import org.hibernate.type.Type;
import org.hibernate.impl.FilterImpl;
import org.hibernate.dialect.Dialect;
import org.hibernate.engine.JoinSequence;
import org.hibernate.engine.QueryParameters;
import org.hibernate.hql.antlr.SqlTokenTypes;
import org.hibernate.hql.ast.HqlSqlWalker;
import org.hibernate.hql.ast.tree.FromClause;
import org.hibernate.hql.ast.tree.FromElement;
import org.hibernate.hql.ast.tree.QueryNode;
import org.hibernate.hql.ast.tree.DotNode;
import org.hibernate.hql.ast.tree.ParameterContainer;
import org.hibernate.hql.classic.ParserHelper;
import org.hibernate.sql.JoinFragment;
import org.hibernate.util.StringHelper;
import org.hibernate.util.ArrayHelper;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * Performs the post-processing of the join information gathered during semantic analysis.
 * The join generating classes are complex, this encapsulates some of the JoinSequence-related
 * code.
 *
 @author Joshua Davis
 */
public class JoinProcessor implements SqlTokenTypes {

  private static final Log log = LogFactory.getLogJoinProcessor.class );

  private final HqlSqlWalker walker;
  private final SyntheticAndFactory syntheticAndFactory;

  /**
   * Constructs a new JoinProcessor.
   *
   @param walker The walker to which we are bound, giving us access to needed resources.
   */
  public JoinProcessor(HqlSqlWalker walker) {
    this.walker = walker;
    this.syntheticAndFactory = new SyntheticAndFactorywalker );
  }

  /**
   * Translates an AST join type (i.e., the token type) into a JoinFragment.XXX join type.
   *
   @param astJoinType The AST join type (from HqlSqlTokenTypes or SqlTokenTypes)
   @return a JoinFragment.XXX join type.
   @see JoinFragment
   @see SqlTokenTypes
   */
  public static int toHibernateJoinType(int astJoinType) {
    switch astJoinType ) {
      case LEFT_OUTER:
        return JoinFragment.LEFT_OUTER_JOIN;
      case INNER:
        return JoinFragment.INNER_JOIN;
      case RIGHT_OUTER:
        return JoinFragment.RIGHT_OUTER_JOIN;
      default:
        throw new AssertionFailure"undefined join type " + astJoinType );
    }
  }

  public void processJoins(QueryNode query) {
    final FromClause fromClause = query.getFromClause();

    final List fromElements;
    if DotNode.useThetaStyleImplicitJoins ) {
      // for regression testing against output from the old parser...
      // found it easiest to simply reorder the FromElements here into ascending order
      // in terms of injecting them into the resulting sql ast in orders relative to those
      // expected by the old parser; this is definitely another of those "only needed
      // for regression purposes".  The SyntheticAndFactory, then, simply injects them as it
      // encounters them.
      fromElements = new ArrayList();
      ListIterator liter = fromClause.getFromElements().listIteratorfromClause.getFromElements().size() );
      while liter.hasPrevious() ) {
        fromElements.addliter.previous() );
      }
    }
    else {
      fromElements = fromClause.getFromElements();
    }

    // Iterate through the alias,JoinSequence pairs and generate SQL token nodes.
    Iterator iter = fromElements.iterator();
    while iter.hasNext() ) {
      final FromElement fromElement = FromElement iter.next();
      JoinSequence join = fromElement.getJoinSequence();
      join.setSelector(
          new JoinSequence.Selector() {
            public boolean includeSubclasses(String alias) {
              // The uber-rule here is that we need to include  subclass joins if
              // the FromElement is in any way dereferenced by a property from
              // the subclass table; otherwise we end up with column references
              // qualified by a non-existent table reference in the resulting SQL...
              boolean containsTableAlias = fromClause.containsTableAliasalias );
              if fromElement.isDereferencedBySubclassProperty() ) {
                // TODO : or should we return 'containsTableAlias'??
                log.trace"forcing inclusion of extra joins [alias=" + alias + ", containsTableAlias=" + containsTableAlias + "]" );
                return true;
              }
              boolean shallowQuery = walker.isShallowQuery();
              boolean includeSubclasses = fromElement.isIncludeSubclasses();
              boolean subQuery = fromClause.isSubQuery();
              return includeSubclasses && containsTableAlias && !subQuery && !shallowQuery;
            }
          }
      );
      addJoinNodesquery, join, fromElement );
    }

  }

  private void addJoinNodes(QueryNode query, JoinSequence join, FromElement fromElement) {
    JoinFragment joinFragment = join.toJoinFragment(
        walker.getEnabledFilters(),
        fromElement.useFromFragment() || fromElement.isDereferencedBySuperclassOrSubclassProperty(),
        fromElement.getWithClauseFragment(),
        fromElement.getWithClauseJoinAlias()
    );

    String frag = joinFragment.toFromFragmentString();
    String whereFrag = joinFragment.toWhereFragmentString();

    // If the from element represents a JOIN_FRAGMENT and it is
    // a theta-style join, convert its type from JOIN_FRAGMENT
    // to FROM_FRAGMENT
    if fromElement.getType() == JOIN_FRAGMENT &&
        join.isThetaStyle() || StringHelper.isNotEmptywhereFrag ) ) ) {
      fromElement.setTypeFROM_FRAGMENT );
      fromElement.getJoinSequence().setUseThetaStyletrue )// this is used during SqlGenerator processing
    }

    // If there is a FROM fragment and the FROM element is an explicit, then add the from part.
    if fromElement.useFromFragment() /*&& StringHelper.isNotEmpty( frag )*/ ) {
      String fromFragment = processFromFragmentfrag, join ).trim();
      if log.isDebugEnabled() ) {
        log.debug"Using FROM fragment [" + fromFragment + "]" );
      }
      processDynamicFilterParameters(
          fromFragment,
          fromElement,
          walker
      );
    }

    syntheticAndFactory.addWhereFragment(
        joinFragment,
        whereFrag,
        query,
        fromElement,
        walker
    );
  }

  private String processFromFragment(String frag, JoinSequence join) {
    String fromFragment = frag.trim();
    // The FROM fragment will probably begin with ', '.  Remove this if it is present.
    if fromFragment.startsWith", " ) ) {
      fromFragment = fromFragment.substring);
    }
    return fromFragment;
  }

  public static void processDynamicFilterParameters(
      final String sqlFragment,
      final ParameterContainer container,
      final HqlSqlWalker walker) {
    if walker.getEnabledFilters().isEmpty()
        && ! hasDynamicFilterParamsqlFragment ) )
        && hasCollectionFilterParamsqlFragment ) ) ) ) {
      return;
    }

    Dialect dialect = walker.getSessionFactoryHelper().getFactory().getDialect();
    String symbols = new StringBuffer().appendParserHelper.HQL_SEPARATORS )
        .appenddialect.openQuote() )
        .appenddialect.closeQuote() )
        .toString();
    StringTokenizer tokens = new StringTokenizersqlFragment, symbols, true );
    StringBuffer result = new StringBuffer();

    while tokens.hasMoreTokens() ) {
      final String token = tokens.nextToken();
      if token.startsWithParserHelper.HQL_VARIABLE_PREFIX ) ) {
        final String filterParameterName = token.substring);
        final String[] parts = QueryParameters.parseFilterParameterNamefilterParameterName );
        final FilterImpl filter = FilterImpl walker.getEnabledFilters().getparts[0] );
        final Object value = filter.getParameterparts[1] );
        final Type type = filter.getFilterDefinition().getParameterTypeparts[1] );
        final String typeBindFragment = StringHelper.join(
            ",",
            ArrayHelper.fillArray"?", type.getColumnSpanwalker.getSessionFactoryHelper().getFactory() ) )
        );
        final String bindFragment = value != null && Collection.class.isInstancevalue ) )
            ? StringHelper.join",", ArrayHelper.fillArraytypeBindFragment, ( ( Collection value ).size() ) )
            : typeBindFragment;
        result.appendbindFragment );
        container.addEmbeddedParameternew DynamicFilterParameterSpecificationparts[0], parts[1], type ) );
      }
      else {
        result.appendtoken );
      }
    }

    container.setTextresult.toString() );
  }

  private static boolean hasDynamicFilterParam(String sqlFragment) {
    return sqlFragment.indexOfParserHelper.HQL_VARIABLE_PREFIX 0;
  }

  private static boolean hasCollectionFilterParam(String sqlFragment) {
    return sqlFragment.indexOf"?" 0;
  }

}