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

org.hibernate.hql.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.
User: josh
Date: Dec 6, 2003
Time: 10:28:17 AM

    // 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;
    Iterator itr = query.getSelectClause().getFromElementsForLoad().iterator();
    while ( itr.hasNext() ) {
      // should be the first, but just to be safe...
      final FromElement fromElement = ( FromElement ) itr.next();
      if ( fromElement.getOrigin() == null ) {
        owner = fromElement;
        break;
      }
    }

View Full Code Here

  }


  private StatementExecutor buildAppropriateStatementExecutor(HqlSqlWalker walker) {
    Statement statement = ( Statement ) walker.getAST();
    if ( walker.getStatementType() == HqlSqlTokenTypes.DELETE ) {
      FromElement fromElement = walker.getFinalFromClause().getFromElement();
      Queryable persister = fromElement.getQueryable();
      if ( persister.isMultiTable() ) {
        return new MultiTableDeleteExecutor( walker );
      }
      else {
        return new BasicExecutor( walker, persister );
      }
    }
    else if ( walker.getStatementType() == HqlSqlTokenTypes.UPDATE ) {
      FromElement fromElement = walker.getFinalFromClause().getFromElement();
      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 perform 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() ) {
        out( ", " );
      }
      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

      //          2) here we would need to track each comparison individually, along with
      //              the join alias to which it applies and then pass that information
      //              back to the FromElement so it can pass it along to the JoinSequence
      if ( node instanceof DotNode ) {
        DotNode dotNode = ( DotNode ) node;
        FromElement fromElement = dotNode.getFromElement();
        if ( referencedFromElement != null ) {
          if ( fromElement != referencedFromElement ) {
            throw new HibernateException( "with-clause referenced two different from-clause elements" );
          }
        }

View Full Code Here

  public Set getQuerySpaces() {
    return querySpaces;
  }


  protected AST createFromElement(String path, AST alias, AST propertyFetch) throws SemanticException {
    FromElement fromElement = currentFromClause.addFromElement( path, alias );
    fromElement.setAllPropertyFetch(propertyFetch!=null);
    return fromElement;
  }

View Full Code Here

    fromElement.setAllPropertyFetch(propertyFetch!=null);
    return fromElement;
  }


  protected AST createFromFilterElement(AST filterEntity, AST alias) throws SemanticException {
    FromElement fromElement = currentFromClause.addFromElement( filterEntity.getText(), alias );
    FromClause fromClause = fromElement.getFromClause();
    QueryableCollection persister = sessionFactoryHelper.getCollectionPersister( collectionFilterRole );
    // Get the names of the columns used to link between the collection
    // owner and the collection elements.
    String[] keyColumnNames = persister.getKeyColumnNames();
    String fkTableAlias = persister.isOneToMany()
        ? fromElement.getTableAlias()
        : fromClause.getAliasGenerator().createName( collectionFilterRole );
    JoinSequence join = sessionFactoryHelper.createJoinSequence();
    join.setRoot( persister, fkTableAlias );
    if ( !persister.isOneToMany() ) {
      join.addJoin( ( AssociationType ) persister.getElementType(),
          fromElement.getTableAlias(),
          JoinFragment.INNER_JOIN,
          persister.getElementColumnNames( fkTableAlias ) );
    }
    join.addCondition( fkTableAlias, keyColumnNames, " = ?" );
    fromElement.setJoinSequence( join );
    fromElement.setFilter( true );
    if ( log.isDebugEnabled() ) {
      log.debug( "createFromFilterElement() : processed filter FROM element." );
    }
    return fromElement;
  }

View Full Code Here

    dot.setJoinType( hibernateJoinType );  // Tell the dot node about the join type.
    dot.setFetch( fetch );
    // Generate an explicit join for the root dot node.   The implied joins will be collected and passed up
    // to the root dot node.
    dot.resolve( true, false, alias == null ? null : alias.getText() );
    FromElement fromElement = dot.getImpliedJoin();
    fromElement.setAllPropertyFetch(propertyFetch!=null);


    if ( with != null ) {
      if ( fetch ) {
        throw new SemanticException( "with-clause not allowed on fetched associations; use filters" );
      }

View Full Code Here

        log.debug( "handleWithFragment() : " + getASTPrinter().showAsString( hqlSqlWithNode, "-- with clause --" ) );
      }
      WithClauseVisitor visitor = new WithClauseVisitor( fromElement );
      NodeTraverser traverser = new NodeTraverser( visitor );
      traverser.traverseDepthFirst( hqlSqlWithNode );
      FromElement referencedFromElement = visitor.getReferencedFromElement();
      if ( referencedFromElement != fromElement ) {
        throw new InvalidWithClauseException( "with-clause expressions did not reference from-clause element to which the with-clause was associated" );
      }
      SqlGenerator sql = new SqlGenerator( getSessionFactoryHelper().getFactory() );
      sql.whereExpr( hqlSqlWithNode.getFirstChild() );

View Full Code Here

    currentFromClause = currentFromClause.getParentFromClause();
  }


  protected void lookupAlias(AST aliasRef)
      throws SemanticException {
    FromElement alias = currentFromClause.getFromElement( aliasRef.getText() );
    FromReferenceNode aliasRefNode = ( FromReferenceNode ) aliasRef;
    aliasRefNode.setFromElement( alias );
  }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

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

org.hibernate.hql.ast.exec.MultiTableDeleteExecutor

org.hibernate.hql.ast.exec.MultiTableUpdateExecutor

org.hibernate.hql.ast.HqlSqlWalker

org.hibernate.hql.ast.HqlSqlWalker$WithClauseVisitor

org.hibernate.hql.ast.QueryTranslatorImpl

org.hibernate.hql.ast.SqlGenerator

org.hibernate.hql.ast.util.JoinProcessor

org.hibernate.loader.hql.QueryLoader

org.hibernate.persister.collection.QueryableCollection

org.hibernate.persister.entity.Queryable

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.