Package org.hibernate.hql.ast.tree

Examples of org.hibernate.hql.ast.tree.DotNode$IllegalCollectionDereferenceExceptionBuilder

763
764
765
766
767
768
769
770
771
772
773
774
  protected void resolveSelectExpression(AST node) throws SemanticException {
    // This is called when it's time to fully resolve a path expression.
    int type = node.getType();
    switch ( type ) {
      case DOT:
        DotNode dot = ( DotNode ) node;
        dot.resolveSelectExpression();
        break;
      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?
View Full Code Here
369
370
371
372
373
374
375
376
377
378
379
380
      //          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
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
    }
    // The path AST should be a DotNode, and it should have been evaluated already.
    if ( path.getType() != SqlTokenTypes.DOT ) {
      throw new SemanticException( "Path expected for join!" );
    }
    DotNode dot = ( DotNode ) path;
    int hibernateJoinType = JoinProcessor.toHibernateJoinType( joinType );
    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
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
  public int getImpliedJoinType() {
    return impliedJoinType;
  }

  protected AST lookupProperty(AST dot, boolean root, boolean inSelect) throws SemanticException {
    DotNode dotNode = ( DotNode ) dot;
    FromReferenceNode lhs = dotNode.getLhs();
    AST rhs = lhs.getNextSibling();
    switch ( rhs.getType() ) {
      case SqlTokenTypes.ELEMENTS:
      case SqlTokenTypes.INDICES:
        if ( log.isDebugEnabled() ) {
          log.debug( "lookupProperty() " + dotNode.getPath() + " => " + rhs.getText() + "(" + lhs.getPath() + ")" );
        }
        CollectionFunction f = ( CollectionFunction ) rhs;
        // Re-arrange the tree so that the collection function is the root and the lhs is the path.
        f.setFirstChild( lhs );
        lhs.setNextSibling( null );
        dotNode.setFirstChild( f );
        resolve( lhs );      // Don't forget to resolve the argument!
        f.resolve( inSelect );  // Resolve the collection function now.
        return f;
      default:
        // Resolve everything up to this dot, but don't resolve the placeholders yet.
        dotNode.resolveFirstChild();
        return dotNode;
    }
  }
View Full Code Here
732
733
734
735
736
737
738
739
740
741
742
743
  protected void resolveSelectExpression(AST node) throws SemanticException {
    // This is called when it's time to fully resolve a path expression.
    int type = node.getType();
    switch ( type ) {
      case DOT:
        DotNode dot = ( DotNode ) node;
        dot.resolveSelectExpression();
        break;
      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?
View Full Code Here
366
367
368
369
370
371
372
373
374
375
376
377
      //          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
459
460
461
462
463
464
465
466
467
468
469
470
      //              linked to different sql joins.
      //          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
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
    }
    // The path AST should be a DotNode, and it should have been evaluated already.
    if ( path.getType() != SqlTokenTypes.DOT ) {
      throw new SemanticException( "Path expected for join!" );
    }
    DotNode dot = ( DotNode ) path;
    int hibernateJoinType = JoinProcessor.toHibernateJoinType( joinType );
    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() );

    final FromElement fromElement;
    if ( dot.getDataType() != null && dot.getDataType().isComponentType() ) {
      FromElementFactory factory = new FromElementFactory(
          getCurrentFromClause(),
          dot.getLhs().getFromElement(),
          dot.getPropertyPath(),
          alias == null ? null : alias.getText(),
          null,
          false
      );
      fromElement = factory.createComponentJoin( (ComponentType) dot.getDataType() );
    }
    else {
      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
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
  public int getImpliedJoinType() {
    return impliedJoinType;
  }

  protected AST lookupProperty(AST dot, boolean root, boolean inSelect) throws SemanticException {
    DotNode dotNode = ( DotNode ) dot;
    FromReferenceNode lhs = dotNode.getLhs();
    AST rhs = lhs.getNextSibling();
    switch ( rhs.getType() ) {
      case SqlTokenTypes.ELEMENTS:
      case SqlTokenTypes.INDICES:
        if ( log.isDebugEnabled() ) {
          log.debug( "lookupProperty() " + dotNode.getPath() + " => " + rhs.getText() + "(" + lhs.getPath() + ")" );
        }
        CollectionFunction f = ( CollectionFunction ) rhs;
        // Re-arrange the tree so that the collection function is the root and the lhs is the path.
        f.setFirstChild( lhs );
        lhs.setNextSibling( null );
        dotNode.setFirstChild( f );
        resolve( lhs );      // Don't forget to resolve the argument!
        f.resolve( inSelect );  // Resolve the collection function now.
        return f;
      default:
        // Resolve everything up to this dot, but don't resolve the placeholders yet.
        dotNode.resolveFirstChild();
        return dotNode;
    }
  }
View Full Code Here
880
881
882
883
884
885
886
887
888
889
890
891
  protected void resolveSelectExpression(AST node) throws SemanticException {
    // This is called when it's time to fully resolve a path expression.
    int type = node.getType();
    switch ( type ) {
      case DOT: {
        DotNode dot = ( DotNode ) node;
        dot.resolveSelectExpression();
        break;
      }
      case ALIAS_REF: {
        // Notify the FROM element that it is being referenced by the select.
        FromReferenceNode aliasRefNode = ( FromReferenceNode ) node;
View Full Code Here
TOP

Related Classes of org.hibernate.hql.ast.tree.DotNode$IllegalCollectionDereferenceExceptionBuilder

  • antlr.collections.AST
  • org.hibernate.engine.JoinSequence
  • org.hibernate.hql.ast.HqlSqlWalker
  • org.hibernate.hql.ast.HqlSqlWalker$WithClauseVisitor
  • org.hibernate.persister.collection.QueryableCollection
  • org.hibernate.persister.entity.EntityPersister
  • org.hibernate.type.Type
  • antlr.SemanticException
  • org.hibernate.QueryException
    • Copyright © 2018 www.massapicom. All rights reserved.
    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.