Examples of org.hibernate.hql.internal.ast.tree.FromElement

Package org.hibernate.hql.internal.ast.tree

Examples of org.hibernate.hql.internal.ast.tree.FromElement

org.hibernate.hql.internal.ast.tree.FromElement
Represents a single mapped class mentioned in an HQL FROM clause. Each class reference will have the following symbols:
- A class name - This is the name of the Java class that is mapped by Hibernate.
- [optional] an HQL alias for the mapped class.
- A table name - The name of the table that is mapped to the Java class.
- A table alias - The alias for the table that will be used in the resulting SQL.
@author josh

      case ALIAS_REF: {
        // Notify the FROM element that it is being referenced by the select.
        FromReferenceNode aliasRefNode = (FromReferenceNode) node;
        //aliasRefNode.resolve( false, false, aliasRefNode.getText() ); //TODO: is it kosher to do it here?
        aliasRefNode.resolve( false, false ); //TODO: is it kosher to do it here?
        FromElement fromElement = aliasRefNode.getFromElement();
        if ( fromElement != null ) {
          fromElement.setIncludeSubclasses( true );
        }
        break;
      }
      default: {
        break;

View Full Code Here

  protected void beforeSelectClause() throws SemanticException {
    // Turn off includeSubclasses on all FromElements.
    FromClause from = getCurrentFromClause();
    List fromElements = from.getFromElements();
    for ( Iterator iterator = fromElements.iterator(); iterator.hasNext(); ) {
      FromElement fromElement = (FromElement) iterator.next();
      fromElement.setIncludeSubclasses( false );
    }
  }

View Full Code Here

      String catalog,
      String schema) {
    super( factory, walker, catalog, schema );


    UpdateStatement updateStatement = ( UpdateStatement ) walker.getAST();
    FromElement fromElement = updateStatement.getFromClause().getFromElement();


    this.targetedPersister = fromElement.getQueryable();
    final String bulkTargetAlias = fromElement.getTableAlias();


    final ProcessedWhereClause processedWhereClause = processWhereClause( updateStatement.getWhereClause() );
    this.idSelectParameterSpecifications = processedWhereClause.getIdSelectParameterSpecifications();
    this.idInsertSelect = generateIdInsertSelect( targetedPersister, bulkTargetAlias, processedWhereClause );
    log.tracev( "Generated ID-INSERT-SELECT SQL (multi-table update) : {0}", idInsertSelect );

View Full Code Here

      String catalog,
      String schema) {
    super( factory, walker, catalog, schema );


    DeleteStatement deleteStatement = ( DeleteStatement ) walker.getAST();
    FromElement fromElement = deleteStatement.getFromClause().getFromElement();


    this.targetedPersister = fromElement.getQueryable();
    final String bulkTargetAlias = fromElement.getTableAlias();


    final ProcessedWhereClause processedWhereClause = processWhereClause( deleteStatement.getWhereClause() );
    this.idSelectParameterSpecifications = processedWhereClause.getIdSelectParameterSpecifications();
    this.idInsertSelect = generateIdInsertSelect( targetedPersister, bulkTargetAlias, processedWhereClause );
    log.tracev( "Generated ID-INSERT-SELECT SQL (multi-table delete) : {0}", idInsertSelect );

View Full Code Here

    // Make sure that there is only a single root entity in the return (no tuples)
    if ( getReturnTypes().length > 1 ) {
      throw new HibernateException( "cannot scroll with collection fetches and returned tuples" );
    }


    FromElement owner = null;
    for ( Object o : query.getSelectClause().getFromElementsForLoad() ) {
      // should be the first, but just to be safe...
      final FromElement fromElement = (FromElement) o;
      if ( fromElement.getOrigin() == null ) {
        owner = fromElement;
        break;
      }
    }

View Full Code Here

  }


  private StatementExecutor buildAppropriateStatementExecutor(HqlSqlWalker walker) {
    final Statement statement = (Statement) walker.getAST();
    if ( walker.getStatementType() == HqlSqlTokenTypes.DELETE ) {
      final FromElement fromElement = walker.getFinalFromClause().getFromElement();
      final Queryable persister = fromElement.getQueryable();
      if ( persister.isMultiTable() ) {
        return new MultiTableDeleteExecutor( walker );
      }
      else {
        return new DeleteExecutor( walker, persister );
      }
    }
    else if ( walker.getStatementType() == HqlSqlTokenTypes.UPDATE ) {
      final FromElement fromElement = walker.getFinalFromClause().getFromElement();
      final Queryable persister = fromElement.getQueryable();
      if ( persister.isMultiTable() ) {
        // even here, if only properties mapped to the "base table" are referenced
        // in the set and where clauses, this could be handled by the BasicDelegate.
        // TODO : decide if it is better performance-wise to doAfterTransactionCompletion that check, or to simply use the MultiTableUpdateDelegate
        return new MultiTableUpdateExecutor( walker );

View Full Code Here

    AST next = a.getNextSibling();
    if ( next == null || !hasText( a ) ) {
      return;
    }


    FromElement left = (FromElement) a;
    FromElement right = (FromElement) next;


    ///////////////////////////////////////////////////////////////////////
    // HACK ALERT !!!!!!!!!!!!!!!!!!!!!!!!!!!!
    // Attempt to work around "ghost" ImpliedFromElements that occasionally
    // show up between the actual things being joined.  This consistently
    // occurs from index nodes (at least against many-to-many).  Not sure
    // if there are other conditions
    //
    // Essentially, look-ahead to the next FromElement that actually
    // writes something to the SQL
    while ( right != null && !hasText( right ) ) {
      right = (FromElement) right.getNextSibling();
    }
    if ( right == null ) {
      return;
    }
    ///////////////////////////////////////////////////////////////////////


    if ( !hasText( right ) ) {
      return;
    }


    if ( right.getRealOrigin() == left ||
        ( right.getRealOrigin() != null && right.getRealOrigin() == left.getRealOrigin() ) ) {
      // right represents a joins originating from left; or
      // both right and left reprersent joins originating from the same FromElement
      if ( right.getJoinSequence() != null && right.getJoinSequence().isThetaStyle() ) {
        writeCrossJoinSeparator();
      }
      else {
        out( " " );
      }

View Full Code Here

    // check a set of parent/child nodes in the from-clause tree
    // to determine if a comma is required between them
    if ( d != null && hasText( d ) ) {
      if ( parent != null && hasText( parent ) ) {
        // again, both should be FromElements
        FromElement left = (FromElement) parent;
        FromElement right = (FromElement) d;
        if ( right.getRealOrigin() == left ) {
          // right represents a joins originating from left...
          if ( right.getJoinSequence() != null && right.getJoinSequence().isThetaStyle() ) {
            out( ", " );
          }
          else {
            out( " " );
          }

View Full Code Here

    }


    // 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.containsTableAlias( alias );
              if ( fromElement.isDereferencedBySubclassProperty() ) {
                // TODO : or should we return 'containsTableAlias'??
                LOG.tracev(
                    "Forcing inclusion of extra joins [alias={0}, containsTableAlias={1}]",
                    alias,
                    containsTableAlias
                );
                return true;
              }
              boolean shallowQuery = walker.isShallowQuery();
              boolean includeSubclasses = fromElement.isIncludeSubclasses();
              boolean subQuery = fromClause.isSubQuery();
              return includeSubclasses && containsTableAlias && !subQuery && !shallowQuery;
            }
          }
      );

View Full Code Here


  public List<FromElement> toFromElements(FromClause fromClause, HqlSqlWalker walker) {
    // If a role already has an explicit fetch in the query, skip it in the graph.
    Map<String, FromElement> explicitFetches = new HashMap<String, FromElement>();
    for ( Object o : fromClause.getFromElements() ) {
      final FromElement fromElement = (FromElement) o;
      if ( fromElement.getRole() != null ) {
        explicitFetches.put( fromElement.getRole(), fromElement );
      }
    }


    return getFromElements(
        originEntityGraph.getAttributeNodes(),

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.hibernate.hql.internal.ast.tree.FromElement

org.hibernate.engine.query.spi.EntityGraphQueryHint

org.hibernate.hql.internal.ast.exec.MultiTableDeleteExecutor

org.hibernate.hql.internal.ast.exec.MultiTableUpdateExecutor

org.hibernate.hql.internal.ast.HqlSqlWalker

org.hibernate.hql.internal.ast.HqlSqlWalker$WithClauseVisitor

org.hibernate.hql.internal.ast.QueryTranslatorImpl

org.hibernate.hql.internal.ast.SqlGenerator

org.hibernate.hql.internal.ast.util.JoinProcessor

org.hibernate.hql.spi.TableBasedDeleteHandlerImpl

org.hibernate.hql.spi.TableBasedUpdateHandlerImpl

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.