* Tests the integration of the new AST parser into the loading of query results using

* the Hibernate persisters and loaders.

* <p/>

* Also used to test the syntax of the resulting sql against the underlying

* database, specifically for functionality not supported by the classic

* parser.

*

* @author Steve

*/

  private static final Log log = LogFactory.getLog( ASTParserLoadingTest.class );

  private List createdAnimalIds = new ArrayList();

  public ASTParserLoadingTest(String name) {

    super( name );

  }

  public String[] getMappings() {

    return new String[] {

        "hql/Animal.hbm.xml",

        "hql/FooBarCopy.hbm.xml",

        "hql/SimpleEntityWithAssociation.hbm.xml",

        "hql/CrazyIdFieldNames.hbm.xml",

        "batchfetch/ProductLine.hbm.xml",

        "cid/Customer.hbm.xml",

        "cid/Order.hbm.xml",

        "cid/LineItem.hbm.xml",

        "cid/Product.hbm.xml",

        "any/Properties.hbm.xml",

        "legacy/Commento.hbm.xml",

        "legacy/Marelo.hbm.xml"

    };

  }

  public void configure(Configuration cfg) {

    super.configure( cfg );

    cfg.setProperty( Environment.USE_QUERY_CACHE, "true" );

    cfg.setProperty( Environment.GENERATE_STATISTICS, "true" );

    cfg.setProperty( Environment.QUERY_TRANSLATOR, ASTQueryTranslatorFactory.class.getName() );

  }

  public static Test suite() {

    return new FunctionalTestClassTestSuite( ASTParserLoadingTest.class );

  }

  public void testComponentNullnessChecks() {

    Session s = openSession();

    s.beginTransaction();

    Human h = new Human();

    h.setName( new Name( "Johnny", 'B', "Goode" ) );

    s.save( h );

    h = new Human();

    h.setName( new Name( "Steve", null, "Ebersole" ) );

    s.save( h );

    h = new Human();

    h.setName( new Name( "Bono", null, null ) );

    s.save( h );

    h = new Human();

    h.setName( new Name( null, null, null ) );

    s.save( h );

    s.getTransaction().commit();

    s.close();

    s = openSession();

    s.beginTransaction();

    List results = s.createQuery( "from Human where name is null" ).list();

    assertEquals( 1, results.size() );

    results = s.createQuery( "from Human where name is not null" ).list();

    assertEquals( 3, results.size() );

    s.createQuery( "from Human where ? is null" ).setParameter( 0, null ).list();

    s.getTransaction().commit();

    s.close();

    s = openSession();

    s.beginTransaction();

    s.createQuery( "delete Human" ).executeUpdate();

    s.getTransaction().commit();

    s.close();

  }

  public void testInvalidCollectionDereferencesFail() {

    Session s = openSession();

    s.beginTransaction();

    // control group...

    s.createQuery( "from Animal a join a.offspring o where o.description = 'xyz'" ).list();

    s.createQuery( "from Animal a join a.offspring o where o.father.description = 'xyz'" ).list();

    s.createQuery( "from Animal a join a.offspring o order by o.description" ).list();

    s.createQuery( "from Animal a join a.offspring o order by o.father.description" ).list();

    try {

      s.createQuery( "from Animal a where a.offspring.description = 'xyz'" ).list();

      fail( "illegal collection dereference semantic did not cause failure" );

    }

    catch( QueryException qe ) {

      log.trace( "expected failure...", qe );

    }

    try {

      s.createQuery( "from Animal a where a.offspring.father.description = 'xyz'" ).list();

      fail( "illegal collection dereference semantic did not cause failure" );

    }

    catch( QueryException qe ) {

      log.trace( "expected failure...", qe );

    }

    try {

      s.createQuery( "from Animal a order by a.offspring.description" ).list();

      fail( "illegal collection dereference semantic did not cause failure" );

    }

    catch( QueryException qe ) {

      log.trace( "expected failure...", qe );

    }

    try {

      s.createQuery( "from Animal a order by a.offspring.father.description" ).list();

      fail( "illegal collection dereference semantic did not cause failure" );

    }

    catch( QueryException qe ) {

      log.trace( "expected failure...", qe );

    }

    s.getTransaction().commit();

    s.close();

  }

  /**

   * Copied from {@link HQLTest#testConcatenation}

   */

  public void testConcatenation() {

    // simple syntax checking...

    Session s = openSession();

    s.beginTransaction();

    s.createQuery( "from Human h where h.nickName = '1' || 'ov' || 'tha' || 'few'" ).list();

    s.getTransaction().commit();

    s.close();

  }

  /**

   * Copied from {@link HQLTest#testExpressionWithParamInFunction}

   */

  public void testExpressionWithParamInFunction() {

    Session s = openSession();

    s.beginTransaction();

    s.createQuery( "from Animal a where abs(a.bodyWeight-:param) < 2.0" ).setLong( "param", 1 ).list();

    s.createQuery( "from Animal a where abs(:param - a.bodyWeight) < 2.0" ).setLong( "param", 1 ).list();

    if ( ( getDialect() instanceof HSQLDialect ) || ( getDialect() instanceof DB2Dialect ) ) {

      // HSQLDB and DB2 don't like the abs(? - ?) syntax. bit work if at least one parameter is typed...

      s.createQuery( "from Animal where abs(cast(:x as long) - :y) < 2.0" ).setLong( "x", 1 ).setLong( "y", 1 ).list();

      s.createQuery( "from Animal where abs(:x - cast(:y as long)) < 2.0" ).setLong( "x", 1 ).setLong( "y", 1 ).list();

      s.createQuery( "from Animal where abs(cast(:x as long) - cast(:y as long)) < 2.0" ).setLong( "x", 1 ).setLong( "y", 1 ).list();     

    }

    else {

      s.createQuery( "from Animal where abs(:x - :y) < 2.0" ).setLong( "x", 1 ).setLong( "y", 1 ).list();

    }

    if ( getDialect() instanceof DB2Dialect ) {

      s.createQuery( "from Animal where lower(upper(cast(:foo as string))) like 'f%'" ).setString( "foo", "foo" ).list();     

    }

    else {

      s.createQuery( "from Animal where lower(upper(:foo)) like 'f%'" ).setString( "foo", "foo" ).list();

    }

    s.createQuery( "from Animal a where abs(abs(a.bodyWeight - 1.0 + :param) * abs(length('ffobar')-3)) = 3.0" ).setLong( "param", 1 ).list();

    if ( getDialect() instanceof DB2Dialect ) {

      s.createQuery( "from Animal where lower(upper('foo') || upper(cast(:bar as string))) like 'f%'" ).setString( "bar", "xyz" ).list();     

    }

    else {

      s.createQuery( "from Animal where lower(upper('foo') || upper(:bar)) like 'f%'" ).setString( "bar", "xyz" ).list();

    }

    if ( ! ( getDialect() instanceof PostgreSQLDialect || getDialect() instanceof MySQLDialect ) ) {

      s.createQuery( "from Animal where abs(cast(1 as float) - cast(:param as float)) = 1.0" ).setLong( "param", 1 ).list();

    }

    s.getTransaction().commit();

    s.close();

  }

  public void testCrazyIdFieldNames() {

    MoreCrazyIdFieldNameStuffEntity top = new MoreCrazyIdFieldNameStuffEntity( "top" );

    HeresAnotherCrazyIdFieldName next = new HeresAnotherCrazyIdFieldName( "next" );

    top.setHeresAnotherCrazyIdFieldName( next );

    MoreCrazyIdFieldNameStuffEntity other = new MoreCrazyIdFieldNameStuffEntity( "other" );

    Session s = openSession();

    s.beginTransaction();

    s.save( next );

    s.save( top );

    s.save( other );

    s.flush();

    List results = s.createQuery( "select e.heresAnotherCrazyIdFieldName from MoreCrazyIdFieldNameStuffEntity e where e.heresAnotherCrazyIdFieldName is not null" ).list();

    assertEquals( 1, results.size() );

    Object result = results.get( 0 );

    assertClassAssignability( HeresAnotherCrazyIdFieldName.class, result.getClass() );

    assertSame( next, result );

    results = s.createQuery( "select e.heresAnotherCrazyIdFieldName.heresAnotherCrazyIdFieldName from MoreCrazyIdFieldNameStuffEntity e where e.heresAnotherCrazyIdFieldName is not null" ).list();

    assertEquals( 1, results.size() );

    result = results.get( 0 );

    assertClassAssignability( Long.class, result.getClass() );

    assertEquals( next.getHeresAnotherCrazyIdFieldName(), result );

    results = s.createQuery( "select e.heresAnotherCrazyIdFieldName from MoreCrazyIdFieldNameStuffEntity e" ).list();

    assertEquals( 1, results.size() );

    Iterator itr = s.createQuery( "select e.heresAnotherCrazyIdFieldName from MoreCrazyIdFieldNameStuffEntity e" ).iterate();

    assertTrue( itr.hasNext() ); itr.next(); assertFalse( itr.hasNext() );

    s.delete( top );

    s.delete( next );

    s.getTransaction().commit();

    s.close();

  }

  public void testImplicitJoinsInDifferentClauses() {

    // HHH-2257 :

    // both the classic and ast translators output the same syntactically valid sql

    // for all of these cases; the issue is that shallow (iterate) and

    // non-shallow (list/scroll) queries return different results because the

    // shallow skips the inner join which "weeds out" results from the non-shallow queries.

    // The results were initially different depending upon the clause(s) in which the

    // implicit join occurred

    Session s = openSession();

    s.beginTransaction();

    SimpleEntityWithAssociation owner = new SimpleEntityWithAssociation( "owner" );

    SimpleAssociatedEntity e1 = new SimpleAssociatedEntity( "thing one", owner );

    SimpleAssociatedEntity e2 = new SimpleAssociatedEntity( "thing two" );

    s.save( e1 );

    s.save( e2 );

    s.save( owner );

    s.getTransaction().commit();

    s.close();

    checkCounts( "select e.owner from SimpleAssociatedEntity e", 1, "implicit-join in select clause" );

    checkCounts( "select e.id, e.owner from SimpleAssociatedEntity e", 1, "implicit-join in select clause" );

    // resolved to a "id short cut" when part of the order by clause -> no inner join = no weeding out...

    checkCounts( "from SimpleAssociatedEntity e order by e.owner", 2, "implicit-join in order-by clause" );

    // resolved to a "id short cut" when part of the group by clause -> no inner join = no weeding out...

    checkCounts( "select e.owner.id, count(*) from SimpleAssociatedEntity e group by e.owner", 2, "implicit-join in select and group-by clauses" );

     s = openSession();

    s.beginTransaction();

    s.delete( e1 );

    s.delete( e2 );

    s.delete( owner );

    s.getTransaction().commit();

    s.close();

  }

  private void checkCounts(String hql, int expected, String testCondition) {

    Session s = openSession();

    s.beginTransaction();

    int count = determineCount( s.createQuery( hql ).list().iterator() );

    assertEquals( "list() [" + testCondition + "]", expected, count );

    count = determineCount( s.createQuery( hql ).iterate() );

    assertEquals( "iterate() [" + testCondition + "]", expected, count );

    s.getTransaction().commit();

    s.close();

  }

  public void testImplicitSelectEntityAssociationInShallowQuery() {

    // HHH-2257 :

    // both the classic and ast translators output the same syntactically valid sql.

    // the issue is that shallow and non-shallow queries return different

    // results because the shallow skips the inner join which "weeds out" results

    // from the non-shallow queries...

    Session s = openSession();

    s.beginTransaction();

    SimpleEntityWithAssociation owner = new SimpleEntityWithAssociation( "owner" );

    SimpleAssociatedEntity e1 = new SimpleAssociatedEntity( "thing one", owner );

    SimpleAssociatedEntity e2 = new SimpleAssociatedEntity( "thing two" );

    s.save( e1 );

    s.save( e2 );

    s.save( owner );

    s.getTransaction().commit();

    s.close();

     s = openSession();

    s.beginTransaction();

    int count = determineCount( s.createQuery( "select e.id, e.owner from SimpleAssociatedEntity e" ).list().iterator() );

    assertEquals( 1, count ); // thing two would be removed from the result due to the inner join

    count = determineCount( s.createQuery( "select e.id, e.owner from SimpleAssociatedEntity e" ).iterate() );

    assertEquals( 1, count );

    s.getTransaction().commit();

    s.close();

     s = openSession();

    s.beginTransaction();

    s.delete( e1 );

    s.delete( e2 );

    s.delete( owner );

    s.getTransaction().commit();

    s.close();

  }

  private int determineCount(Iterator iterator) {

    int count = 0;

    while( iterator.hasNext() ) {

      count++;

      iterator.next();

    }

    return count;

  }

  public void testNestedComponentIsNull() {

    // (1) From MapTest originally...

    // (2) Was then moved into HQLTest...

    // (3) However, a bug fix to EntityType#getIdentifierOrUniqueKeyType (HHH-2138)

    //     caused the classic parser to suddenly start throwing exceptions on

    //    this query, apparently relying on the buggy behavior somehow; thus

    //    moved here to at least get some syntax checking...

    //

    // fyi... found and fixed the problem in the classic parser; still

    // leaving here for syntax checking

    new SyntaxChecker( "from Commento c where c.marelo.commento.mcompr is null" ).checkAll();

  }

  public void testSpecialClassPropertyReference() {

    // this is a long standing bug in Hibernate when applied to joined-subclasses;

    //  see HHH-939 for details and history

    new SyntaxChecker( "from Zoo zoo where zoo.class = PettingZoo" ).checkAll();

    new SyntaxChecker( "select a.description from Animal a where a.class = Mammal" ).checkAll();

    new SyntaxChecker( "select a.class from Animal a" ).checkAll();

    new SyntaxChecker( "from DomesticAnimal an where an.class = Dog" ).checkAll();

    new SyntaxChecker( "from Animal an where an.class = Dog" ).checkAll();

  }

  public void testSpecialClassPropertyReferenceFQN() {

    // tests relating to HHH-2376

    new SyntaxChecker( "from Zoo zoo where zoo.class = org.hibernate.test.hql.PettingZoo" ).checkAll();

    new SyntaxChecker( "select a.description from Animal a where a.class = org.hibernate.test.hql.Mammal" ).checkAll();

    new SyntaxChecker( "from DomesticAnimal an where an.class = org.hibernate.test.hql.Dog" ).checkAll();

    new SyntaxChecker( "from Animal an where an.class = org.hibernate.test.hql.Dog" ).checkAll();

  }

  public void testSubclassOrSuperclassPropertyReferenceInJoinedSubclass() {

    // this is a long standing bug in Hibernate; see HHH-1631 for details and history

    //

    // (1) pregnant is defined as a property of the class (Mammal) itself

    // (2) description is defined as a property of the superclass (Animal)

    // (3) name is defined as a property of a particular subclass (Human)

    new SyntaxChecker( "from Zoo z join z.mammals as m where m.name.first = 'John'" ).checkIterate();

    new SyntaxChecker( "from Zoo z join z.mammals as m where m.pregnant = false" ).checkAll();

    new SyntaxChecker( "select m.pregnant from Zoo z join z.mammals as m where m.pregnant = false" ).checkAll();

    new SyntaxChecker( "from Zoo z join z.mammals as m where m.description = 'tabby'" ).checkAll();

    new SyntaxChecker( "select m.description from Zoo z join z.mammals as m where m.description = 'tabby'" ).checkAll();

    new SyntaxChecker( "from Zoo z join z.mammals as m where m.name.first = 'John'" ).checkAll();

    new SyntaxChecker( "select m.name from Zoo z join z.mammals as m where m.name.first = 'John'" ).checkAll();

    new SyntaxChecker( "select m.pregnant from Zoo z join z.mammals as m" ).checkAll();

    new SyntaxChecker( "select m.description from Zoo z join z.mammals as m" ).checkAll();

    new SyntaxChecker( "select m.name from Zoo z join z.mammals as m" ).checkAll();

    new SyntaxChecker( "from DomesticAnimal da join da.owner as o where o.nickName = 'Gavin'" ).checkAll();

    new SyntaxChecker( "select da.father from DomesticAnimal da join da.owner as o where o.nickName = 'Gavin'" ).checkAll();

  }

  public void testSimpleSelectWithLimitAndOffset() throws Exception {

    if ( ! ( getDialect().supportsLimit() && getDialect().supportsLimitOffset() ) ) {

      reportSkip( "dialect does not support offset and limit combo", "limit and offset combination" );

      return;

    }

    // just checking correctness of param binding code...

    Session session = openSession();

    session.createQuery( "from Animal" )

        .setFirstResult( 2 )

        .setMaxResults( 1 )

        .list();

    session.close();

  }

  public void testJPAPositionalParameterList() {

    Session s = openSession();

    s.beginTransaction();

    ArrayList params = new ArrayList();

    params.add( "Doe" );

    params.add( "Public" );

    s.createQuery( "from Human where name.last in (?1)" )

        .setParameterList( "1", params )

        .list();

    s.getTransaction().commit();

    s.close();

  }

  public void testComponentQueries() {

    Session s = openSession();

    s.beginTransaction();

    Type[] types = s.createQuery( "select h.name from Human h" ).getReturnTypes();

    assertEquals( 1, types.length );

    assertTrue( types[0] instanceof ComponentType );

    // Test the ability to perform comparisions between component values

    s.createQuery( "from Human h where h.name = h.name" ).list();

    s.createQuery( "from Human h where h.name = :name" ).setParameter( "name", new Name() ).list();

    s.createQuery( "from Human where name = :name" ).setParameter( "name", new Name() ).list();

    s.createQuery( "from Human h where :name = h.name" ).setParameter( "name", new Name() ).list();

    s.createQuery( "from Human h where :name <> h.name" ).setParameter( "name", new Name() ).list();

    // Test the ability to perform comparisions between a component and an explicit row-value

    s.createQuery( "from Human h where h.name = ('John', 'X', 'Doe')" ).list();

    s.createQuery( "from Human h where ('John', 'X', 'Doe') = h.name" ).list();

    s.createQuery( "from Human h where ('John', 'X', 'Doe') <> h.name" ).list();

    s.createQuery( "from Human h where ('John', 'X', 'Doe') >= h.name" ).list();

    s.createQuery( "from Human h order by h.name" ).list();

    s.getTransaction().commit();

    s.close();

  }

  public void testComponentParameterBinding() {

    // HHH-1774 : parameters are bound incorrectly with component parameters...

    Session s = openSession();

    s.beginTransaction();

    Order.Id oId = new Order.Id( "1234", 1 );

    // control

    s.createQuery("from Order o where o.customer.name =:name and o.id = :id")

        .setParameter( "name", "oracle" )

        .setParameter( "id", oId )

        .list();

    // this is the form that caused problems in the original case...

    s.createQuery("from Order o where o.id = :id and o.customer.name =:name ")

        .setParameter( "id", oId )

        .setParameter( "name", "oracle" )

        .list();

    s.getTransaction().commit();

    s.close();

  }

  public void testAnyMappingReference() {

    Session s = openSession();

    s.beginTransaction();

    PropertyValue redValue = new StringPropertyValue( "red" );

    PropertyValue lonliestNumberValue = new IntegerPropertyValue( 1 );

    Long id;

    PropertySet ps = new PropertySet( "my properties" );

    ps.setSomeSpecificProperty( redValue );

    ps.getGeneralProperties().put( "the lonliest number", lonliestNumberValue );

    ps.getGeneralProperties().put( "i like", new StringPropertyValue( "pina coladas" ) );

    ps.getGeneralProperties().put( "i also like", new StringPropertyValue( "getting caught in the rain" ) );

    s.save( ps );

    s.getTransaction().commit();

    id = ps.getId();

    s.clear();

    s.beginTransaction();

    // TODO : setEntity() currently will not work here, but that would be *very* nice

    // does not work because the corresponding EntityType is then used as the "bind type" rather

    // than the "discovered" AnyType...

    s.createQuery( "from PropertySet p where p.someSpecificProperty = :ssp" ).setParameter( "ssp", redValue ).list();

    s.createQuery( "from PropertySet p where p.someSpecificProperty.id is not null" ).list();

    s.createQuery( "from PropertySet p join p.generalProperties gp where gp.id is not null" ).list();

    s.delete( s.load( PropertySet.class, id ) );

    s.getTransaction().commit();

    s.close();

  }

  public void testJdkEnumStyleEnumConstant() throws Exception {

    Session s = openSession();

    s.beginTransaction();

    s.createQuery( "from Zoo z where z.classification = org.hibernate.test.hql.Classification.LAME" ).list();

    s.getTransaction().commit();

    s.close();

  }

  public void testParameterTypeMismatchFailureExpected() {

    Session s = openSession();

    s.beginTransaction();

    Query query = s.createQuery( "from Animal a where a.description = :nonstring" )

        .setParameter( "nonstring", new Integer(1) );

    try {

      query.list();

      fail( "query execution should have failed" );

    }

    catch( TypeMismatchException tme ) {

      // expected behavior

    }

    s.getTransaction().commit();

    s.close();

  }

  public void testMultipleBagFetchesFail() {

    Session s = openSession();

    s.beginTransaction();

    try {

      s.createQuery( "from Human h join fetch h.friends f join fetch f.friends fof" ).list();

      fail( "failure expected" );

    }

    catch( HibernateException e ) {

      assertTrue( "unexpected failure reason : " + e, e.getMessage().indexOf( "multiple bags" ) > 0 );

    }

    s.getTransaction().commit();

    s.close();

  }

  public void testCollectionJoinsInSubselect() {

    // HHH-1248 : initially FromElementFactory treated any explicit join

    // as an implied join so that theta-style joins would always be used.

    // This was because correlated subqueries cannot use ANSI-style joins

    // for the correlation.  However, this special treatment was not limited

    // to only correlated subqueries; it was applied to any subqueries ->

    // which in-and-of-itself is not necessarily bad.  But somewhere later

    // the choices made there caused joins to be dropped.

    Session s = openSession();

    String qryString =

        "select a.id, a.description" +

        " from Animal a" +

        "       left join a.offspring" +

        " where a in (" +

        "       select a1 from Animal a1" +

        "           left join a1.offspring o" +

        "       where a1.id=1" +

            ")";

    s.createQuery( qryString ).list();

    qryString =

        "select h.id, h.description" +

            " from Human h" +

        "      left join h.friends" +

        " where h in (" +

        "      select h1" +

        "      from Human h1" +

        "          left join h1.friends f" +

        "      where h1.id=1" +

        ")";

    s.createQuery( qryString ).list();

    qryString =

        "select h.id, h.description" +

            " from Human h" +

        "      left join h.friends f" +

        " where f in (" +

        "      select h1" +

        "      from Human h1" +

        "          left join h1.friends f1" +

        "      where h = f1" +

        ")";

    s.createQuery( qryString ).list();

    s.close();

  }

  public void testCollectionFetchWithDistinctionAndLimit() {

    // create some test data...

    Session s = openSession();

    Transaction t = s.beginTransaction();

    int parentCount = 30;

    for ( int i = 0; i < parentCount; i++ ) {

      Animal child1 = new Animal();

      child1.setDescription( "collection fetch distinction (child1 - parent" + i + ")" );

      s.persist( child1 );

      Animal child2 = new Animal();

      child2.setDescription( "collection fetch distinction (child2 - parent " + i + ")" );

      s.persist( child2 );

      Animal parent = new Animal();

      parent.setDescription( "collection fetch distinction (parent" + i + ")" );

      parent.setSerialNumber( "123-" + i );

      parent.addOffspring( child1 );

      parent.addOffspring( child2 );

      s.persist( parent );

    }

    t.commit();

    s.close();

    s = openSession();

    t = s.beginTransaction();

    // Test simple distinction

    List results;

    results = s.createQuery( "select distinct p from Animal p inner join fetch p.offspring" ).list();

    assertEquals( "duplicate list() returns", 30, results.size() );

    // Test first/max

    results = s.createQuery( "select p from Animal p inner join fetch p.offspring order by p.id" )

        .setFirstResult( 5 )

        .setMaxResults( 20 )

        .list();

    assertEquals( "duplicate returns", 20, results.size() );

    Animal firstReturn = ( Animal ) results.get( 0 );

    assertEquals( "firstResult not applied correctly", "123-5", firstReturn.getSerialNumber() );

    t.commit();

    s.close();

    s = openSession();

    t = s.beginTransaction();

    s.createQuery( "delete Animal where mother is not null" ).executeUpdate();

    s.createQuery( "delete Animal" ).executeUpdate();

    t.commit();

    s.close();

  }

  public void testFetchInSubqueryFails() {

    Session s = openSession();

    try {

      s.createQuery( "from Animal a where a.mother in (select m from Animal a1 inner join a1.mother as m join fetch m.mother)" ).list();

      fail( "fetch join allowed in subquery" );

    }

    catch( QueryException expected ) {

      // expected behavior

    }

    s.close();

  }

  public void testQueryMetadataRetrievalWithFetching() {

    // HHH-1464 : there was a problem due to the fact they we polled

    // the shallow version of the query plan to get the metadata.

    Session s = openSession();

    Query query = s.createQuery( "from Animal a inner join fetch a.mother" );

    assertEquals( 1, query.getReturnTypes().length );

    assertNull( query.getReturnAliases() );

    s.close();

  }

  public void testSuperclassPropertyReferenceAfterCollectionIndexedAccess() {

    // note: simply performing syntax checking in the db

    // test for HHH-429

    Session s = openSession();

    s.beginTransaction();

    Mammal tiger = new Mammal();

    tiger.setDescription( "Tiger" );

    s.persist( tiger );

    Mammal mother = new Mammal();

    mother.setDescription( "Tiger's mother" );

    mother.setBodyWeight( 4.0f );

    mother.addOffspring( tiger );

    s.persist( mother );

    Zoo zoo = new Zoo();

    zoo.setName( "Austin Zoo" );

    zoo.setMammals( new HashMap() );

    zoo.getMammals().put( "tiger", tiger );

    s.persist( zoo );

    s.getTransaction().commit();

    s.close();

    s = openSession();

    s.beginTransaction();

    List results = s.createQuery( "from Zoo zoo where zoo.mammals['tiger'].mother.bodyWeight > 3.0f" ).list();

    assertEquals( 1, results.size() );

    s.getTransaction().commit();

    s.close();

    s = openSession();

    s.beginTransaction();

    s.delete( tiger );

    s.delete( mother );

    s.delete( zoo );

    s.getTransaction().commit();

    s.close();

  }

  public void testJoinFetchCollectionOfValues() {

    // note: simply performing syntax checking in the db

    Session s = openSession();

    s.beginTransaction();

    s.createQuery( "select h from Human as h join fetch h.nickNames" ).list();

    s.getTransaction().commit();

    s.close();

  }

  public void testIntegerLiterals() {

    // note: simply performing syntax checking in the db

    Session s = openSession();

    s.beginTransaction();

    s.createQuery( "from Foo where long = 1" ).list();

    s.createQuery( "from Foo where long = " + Integer.MIN_VALUE ).list();

    s.createQuery( "from Foo where long = " + Integer.MAX_VALUE ).list();

    s.createQuery( "from Foo where long = 1L" ).list();

    s.createQuery( "from Foo where long = " + (Long.MIN_VALUE + 1) + "L" ).list();

    s.createQuery( "from Foo where long = " + Long.MAX_VALUE + "L" ).list();

    s.createQuery( "from Foo where integer = " + (Long.MIN_VALUE + 1) ).list();

//    s.createQuery( "from Foo where long = " + Long.MIN_VALUE ).list();

    s.getTransaction().commit();

    s.close();

  }

  public void testDecimalLiterals() {

    // note: simply performing syntax checking in the db

    Session s = openSession();

    s.beginTransaction();

    s.createQuery( "from Animal where bodyWeight > 100.0e-10" ).list();

    s.createQuery( "from Animal where bodyWeight > 100.0E-10" ).list();

    s.createQuery( "from Animal where bodyWeight > 100.001f" ).list();

    s.createQuery( "from Animal where bodyWeight > 100.001F" ).list();

    s.createQuery( "from Animal where bodyWeight > 100.001d" ).list();

    s.createQuery( "from Animal where bodyWeight > 100.001D" ).list();

    s.createQuery( "from Animal where bodyWeight > .001f" ).list();

    s.createQuery( "from Animal where bodyWeight > 100e-10" ).list();

    s.createQuery( "from Animal where bodyWeight > .01E-10" ).list();

    s.createQuery( "from Animal where bodyWeight > 1e-38" ).list();

    s.getTransaction().commit();

    s.close();

  }

  public void testNakedPropertyRef() {

    // note: simply performing syntax and column/table resolution checking in the db

    Session s = openSession();

    s.beginTransaction();

    s.createQuery( "from Animal where bodyWeight = bodyWeight" ).list();

    s.createQuery( "select bodyWeight from Animal" ).list();

    s.createQuery( "select max(bodyWeight) from Animal" ).list();

    s.getTransaction().commit();

    s.close();

  }

  public void testNakedComponentPropertyRef() {

    // note: simply performing syntax and column/table resolution checking in the db

    Session s = openSession();

    s.beginTransaction();

    s.createQuery( "from Human where name.first = 'Gavin'" ).list();

    s.createQuery( "select name from Human" ).list();

    s.createQuery( "select upper(h.name.first) from Human as h" ).list();

    s.createQuery( "select upper(name.first) from Human" ).list();

    s.getTransaction().commit();

    s.close();

  }

  public void testNakedImplicitJoins() {

    // note: simply performing syntax and column/table resolution checking in the db

    Session s = openSession();

    s.beginTransaction();

    s.createQuery( "from Animal where mother.father.id = 1" ).list();

    s.getTransaction().commit();

    s.close();

  }

  public void testNakedEntityAssociationReference() {

    // note: simply performing syntax and column/table resolution checking in the db

    Session s = openSession();

    s.beginTransaction();

    s.createQuery( "from Animal where mother = :mother" ).setParameter( "mother", null ).list();

    s.getTransaction().commit();

    s.close();

  }

  public void testNakedMapIndex() throws Exception {

    // note: simply performing syntax and column/table resolution checking in the db

    Session s = openSession();

    s.beginTransaction();

    s.createQuery( "from Zoo where mammals['dog'].description like '%black%'" ).list();

    s.getTransaction().commit();

    s.close();

  }

  public void testInvalidFetchSemantics() {

    Session s = openSession();

    s.beginTransaction();

    try {

      s.createQuery( "select mother from Human a left join fetch a.mother mother" ).list();

      fail( "invalid fetch semantic allowed!" );

    }

    catch( QueryException e ) {

    }

    try {

      s.createQuery( "select mother from Human a left join fetch a.mother mother" ).list();

      fail( "invalid fetch semantic allowed!" );

    }

    catch( QueryException e ) {

    }

    s.getTransaction().commit();

    s.close();

  }

  public void testArithmetic() {

    Session s = openSession();

    Transaction t = s.beginTransaction();

    Zoo zoo = new Zoo();

    zoo.setName("Melbourne Zoo");

    s.persist(zoo);

    s.createQuery("select 2*2*2*2*(2*2) from Zoo").uniqueResult();

    s.createQuery("select 2 / (1+1) from Zoo").uniqueResult();

    int result0 = ( (Integer) s.createQuery("select 2 - (1+1) from Zoo").uniqueResult() ).intValue();

    int result1 = ( (Integer) s.createQuery("select 2 - 1 + 1 from Zoo").uniqueResult() ).intValue();

    int result2 = ( (Integer) s.createQuery("select 2 * (1-1) from Zoo").uniqueResult() ).intValue();

    int result3 = ( (Integer) s.createQuery("select 4 / (2 * 2) from Zoo").uniqueResult() ).intValue();

    int result4 = ( (Integer) s.createQuery("select 4 / 2 * 2 from Zoo").uniqueResult() ).intValue();

    int result5 = ( (Integer) s.createQuery("select 2 * (2/2) from Zoo").uniqueResult() ).intValue();

    int result6 = ( (Integer) s.createQuery("select 2 * (2/2+1) from Zoo").uniqueResult() ).intValue();

    assertEquals(result0, 0);

    assertEquals(result1, 2);

    assertEquals(result2, 0);

    assertEquals(result3, 1);

    assertEquals(result4, 4);

    assertEquals(result5, 2);

    assertEquals(result6, 4);

    s.delete(zoo);

    t.commit();

    s.close();

  }

  public void testNestedCollectionFetch() {

    Session s = openSession();

    Transaction t = s.beginTransaction();

    s.createQuery("from Animal a left join fetch a.offspring o left join fetch o.offspring where a.mother.id = 1 order by a.description").list();

    s.createQuery("from Zoo z left join fetch z.animals a left join fetch a.offspring where z.name ='MZ' order by a.description").list();

    s.createQuery("from Human h left join fetch h.pets a left join fetch a.offspring where h.name.first ='Gavin' order by a.description").list();

    t.commit();

    s.close();

  }

  public void testSelectClauseSubselect() {

    Session s = openSession();

    Transaction t = s.beginTransaction();

    Zoo zoo = new Zoo();

    zoo.setName("Melbourne Zoo");

    zoo.setMammals( new HashMap() );

    zoo.setAnimals( new HashMap() );

    Mammal plat = new Mammal();

    plat.setBodyWeight( 11f );

    plat.setDescription( "Platypus" );

    plat.setZoo(zoo);

    plat.setSerialNumber("plat123");

    zoo.getMammals().put("Platypus", plat);

    zoo.getAnimals().put("plat123", plat);

    s.persist( plat );

    s.persist(zoo);

    s.createQuery("select (select max(z.id) from a.zoo z) from Animal a").list();