* 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 Logger log = LoggerFactory.getLogger( 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",

        "hql/Image.hbm.xml",

        "hql/ComponentContainer.hbm.xml",

        "hql/VariousKeywordPropertyEntity.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 testSubSelectAsArtithmeticOperand() {

    Session s = openSession();

    s.beginTransaction();

    // first a control

    s.createQuery( "from Zoo z where ( select count(*) from Zoo ) = 0" ).list();

    // now as operands singly:

    s.createQuery( "from Zoo z where ( select count(*) from Zoo ) + 0 = 0" ).list();

    s.createQuery( "from Zoo z where 0 + ( select count(*) from Zoo ) = 0" ).list();

    // and doubly:

    s.createQuery( "from Zoo z where ( select count(*) from Zoo ) + ( select count(*) from Zoo ) = 0" ).list();

    s.getTransaction().commit();

    s.close();

  }

  public void testJpaTypeOperator() {

    // just checking syntax here...

    Session s = openSession();

    s.beginTransaction();

    ///////////////////////////////////////////////////////////////

    // where clause

    // control

    s.createQuery( "from Animal a where a.class = Dog" ).list();

        // test

    s.createQuery( "from Animal a where type(a) = Dog" ).list();

    ///////////////////////////////////////////////////////////////

    // select clause (at some point we should unify these)

    // control

    Query query = s.createQuery( "select a.class from Animal a where a.class = Dog" );

    query.list(); // checks syntax

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

    assertEquals( Integer.class, query.getReturnTypes()[0].getReturnedClass() ); // always integer for joined

        // test

    query = s.createQuery( "select type(a) from Animal a where type(a) = Dog" );

    query.list(); // checks syntax

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

    assertEquals( DiscriminatorType.class, query.getReturnTypes()[0].getClass() );

    assertEquals( Class.class, query.getReturnTypes()[0].getReturnedClass() );

    s.getTransaction().commit();

    s.close();

  }

  public void testComponentJoins() {

    Session s = openSession();

    s.beginTransaction();

    ComponentContainer root = new ComponentContainer(

        new ComponentContainer.Address(

            "123 Main",

            "Anywhere",

            "USA",

            new ComponentContainer.Address.Zip( 12345, 6789 )

        )

    );

    s.save( root );

    s.getTransaction().commit();

    s.close();

    s = openSession();

    s.beginTransaction();

    List result = s.createQuery( "select a from ComponentContainer c join c.address a" ).list();

    assertEquals( 1, result.size() );

    assertTrue( ComponentContainer.Address.class.isInstance( result.get( 0 ) ) );

    result = s.createQuery( "select a.zip from ComponentContainer c join c.address a" ).list();

    assertEquals( 1, result.size() );

    assertTrue( ComponentContainer.Address.Zip.class.isInstance( result.get( 0 ) ) );

    result = s.createQuery( "select z from ComponentContainer c join c.address a join a.zip z" ).list();

    assertEquals( 1, result.size() );

    assertTrue( ComponentContainer.Address.Zip.class.isInstance( result.get( 0 ) ) );

    result = s.createQuery( "select z.code from ComponentContainer c join c.address a join a.zip z" ).list();

    assertEquals( 1, result.size() );

    assertTrue( Integer.class.isInstance( result.get( 0 ) ) );

    s.delete( root );

    s.getTransaction().commit();

    s.close();

  }

  public void testJPAQLQualifiedIdentificationVariablesControl() {

    // just checking syntax here...

    Session s = openSession();

    s.beginTransaction();

    s.createQuery( "from VariousKeywordPropertyEntity where type = 'something'" ).list();

    s.createQuery( "from VariousKeywordPropertyEntity where value = 'something'" ).list();

    s.createQuery( "from VariousKeywordPropertyEntity where key = 'something'" ).list();

    s.createQuery( "from VariousKeywordPropertyEntity where entry = 'something'" ).list();

    s.createQuery( "from VariousKeywordPropertyEntity e where e.type = 'something'" ).list();

    s.createQuery( "from VariousKeywordPropertyEntity e where e.value = 'something'" ).list();

    s.createQuery( "from VariousKeywordPropertyEntity e where e.key = 'something'" ).list();

    s.createQuery( "from VariousKeywordPropertyEntity e where e.entry = 'something'" ).list();

    s.getTransaction().commit();

    s.close();

  }

  public void testJPAQLQualifiedIdentificationVariables() {

    Session s = openSession();

    s.beginTransaction();

    Human me = new Human();

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

    Human joe = new Human();

    me.setName( new Name( "Joe", null, "Ebersole" ) );

    me.setFamily( new HashMap() );

    me.getFamily().put( "son", joe );

    s.save( me );

    s.save( joe );

    s.getTransaction().commit();

    s.close();

    s = openSession();

    s.beginTransaction();

    List results = s.createQuery( "select entry(h.family) from Human h" ).list();

    assertEquals( 1, results.size() );

    Object result = results.get(0);

    assertTrue( Map.Entry.class.isAssignableFrom( result.getClass() ) );

    Map.Entry entry = (Map.Entry) result;

    assertTrue( String.class.isAssignableFrom( entry.getKey().getClass() ) );

    assertTrue( Human.class.isAssignableFrom( entry.getValue().getClass() ) );

    s.getTransaction().commit();

    s.close();

    s = openSession();

    s.beginTransaction();

    results = s.createQuery( "select distinct key(h.family) from Human h" ).list();

    assertEquals( 1, results.size() );

    Object key = results.get(0);

    assertTrue( String.class.isAssignableFrom( key.getClass() ) );

    s.getTransaction().commit();

    s.close();

    s = openSession();

    s.beginTransaction();

    s.delete( me );

    s.delete( joe );

    s.getTransaction().commit();

    s.close();

  }

  public void testPaginationWithPolymorphicQuery() {

    if ( getDialect() instanceof IngresDialect ) {

      // HHH-4961 Ingres does not support this scoping in 9.3.

      return;

    }

    Session s = openSession();

    s.beginTransaction();

    Human h = new Human();

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

    s.save( h );

    s.getTransaction().commit();

    s.close();

    s = openSession();

    s.beginTransaction();

    List results = s.createQuery( "from java.lang.Object" ).setMaxResults( 2 ).list();

    assertEquals( 1, results.size() );

    s.getTransaction().commit();

    s.close();

    s = openSession();

    s.beginTransaction();

    s.delete( h );

    s.getTransaction().commit();

    s.close();

  }

  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() );

    String query =

        ( getDialect() instanceof DB2Dialect || getDialect() instanceof HSQLDialect ) ?

            "from Human where cast(? as string) is null" :

            "from Human where ? is null"

        ;

    s.createQuery( query ).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.delete( other );

    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();

  }

  public void testRowValueConstructorSyntaxInInList() {

    Session s = openSession();

    s.beginTransaction();

    Product product = new Product();

    product.setDescription( "My Product" );

    product.setNumberAvailable( 10 );

    product.setPrice( new BigDecimal( 123 ) );

    product.setProductId( "4321" );

    s.save( product );

   

    Customer customer = new Customer();

    customer.setCustomerId( "123456789" );

    customer.setName( "My customer" );

    customer.setAddress( "somewhere" );

    s.save( customer );

    Order order = customer.generateNewOrder( new BigDecimal( 1234 ) );

    s.save( order );

    LineItem li = order.generateLineItem( product, 5 );

    s.save( li );

    product = new Product();

    product.setDescription( "My Product" );

    product.setNumberAvailable( 10 );

    product.setPrice( new BigDecimal( 123 ) );

    product.setProductId( "1234" );

    s.save( product );

    li = order.generateLineItem( product, 10 );

    s.save( li );

    s.flush();

    Query query = s.createQuery( "from LineItem l where l.id in (:idList)" );

    List list = new ArrayList();

    list.add( new Id("123456789", order.getId().getOrderNumber(), "4321") );

    list.add( new Id("123456789", order.getId().getOrderNumber(), "1234") );

    query.setParameterList( "idList", list );

    assertEquals( 2, query.list().size() );

    query = s.createQuery( "from LineItem l where l.id in :idList" );

    query.setParameterList( "idList", list );

    assertEquals( 2, query.list().size() );

    s.getTransaction().rollback();

    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 testEntityAndOneToOneReturnedByQuery() {

    Session s = openSession();

    s.beginTransaction();

    Human h = new Human();