Attachment #249144 for bug #395738

Lines 843-848 Link Here

(-)a/jpa/eclipselink.jpa.test/antbuild.xml (+1 lines)
843	org/eclipse/persistence/testing/models/jpa/cacheable/**	843	org/eclipse/persistence/testing/models/jpa/cacheable/**
844	org/eclipse/persistence/testing/models/jpa/cascadedeletes/**	844	org/eclipse/persistence/testing/models/jpa/cascadedeletes/**
845	org/eclipse/persistence/testing/models/jpa/complexaggregate/**	845	org/eclipse/persistence/testing/models/jpa/complexaggregate/**
		846	org/eclipse/persistence/testing/models/jpa/customer/**
846	org/eclipse/persistence/testing/models/jpa/datatypes/**	847	org/eclipse/persistence/testing/models/jpa/datatypes/**
847	org/eclipse/persistence/testing/models/jpa/datetime/**	848	org/eclipse/persistence/testing/models/jpa/datetime/**
848	org/eclipse/persistence/testing/models/jpa/inheritance/**	849	org/eclipse/persistence/testing/models/jpa/inheritance/**




        <exclude-unlisted-classes>true</exclude-unlisted-classes>
        <shared-cache-mode>DISABLE_SELECTIVE</shared-cache-mode>
    </persistence-unit>

    <!-- Advanced customer model persistence unit. -->
    <persistence-unit name="customer-pu" transaction-type="RESOURCE_LOCAL">
        <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
        <shared-cache-mode>NONE</shared-cache-mode>
        <class>org.eclipse.persistence.testing.models.jpa.advanced.customer.CustomerAddress</class>
        <class>org.eclipse.persistence.testing.models.jpa.advanced.customer.AddressType1</class>
        <class>org.eclipse.persistence.testing.models.jpa.advanced.customer.AddressType2</class>
        <class>org.eclipse.persistence.testing.models.jpa.advanced.customer.RegisteredCustomer</class>
        <exclude-unlisted-classes>true</exclude-unlisted-classes>
        <properties>
            <property name="eclipselink.logging.level" value="FINE" />
            <property name="eclipselink.logging.level.sql" value="FINEST"/>
            <property name="eclipselink.logging.level.cache" value="FINEST" />
            <property name="eclipselink.logging.parameters" value="true"/>
            <property name="eclipselink.ddl-generation" value="drop-and-create-tables" />
            <property name="eclipselink.ddl-generation.output-mode" value="database" />
        </properties>
    </persistence-unit>

</persistence>




			<property name="eclipselink.validation-only" value="true"/>
		</properties>
	</persistence-unit>

    <!-- Advanced customer model persistence unit. -->
    <persistence-unit name="customer-pu" transaction-type="RESOURCE_LOCAL">
        <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
        <shared-cache-mode>NONE</shared-cache-mode>
        <class>org.eclipse.persistence.testing.models.jpa.advanced.customer.CustomerAddress</class>
        <class>org.eclipse.persistence.testing.models.jpa.advanced.customer.AddressType1</class>
        <class>org.eclipse.persistence.testing.models.jpa.advanced.customer.AddressType2</class>
        <class>org.eclipse.persistence.testing.models.jpa.advanced.customer.RegisteredCustomer</class>
        <exclude-unlisted-classes>true</exclude-unlisted-classes>
        <properties>
            <property name="eclipselink.logging.level" value="FINE" />
            <property name="eclipselink.logging.level.sql" value="FINEST"/>
            <property name="eclipselink.logging.level.cache" value="FINEST" />
            <property name="eclipselink.logging.parameters" value="true"/>
            <property name="eclipselink.ddl-generation" value="drop-and-create-tables" />
            <property name="eclipselink.ddl-generation.output-mode" value="database" />
        </properties>
    </persistence-unit>

</persistence>




            <property name="eclipselink.session-name" value="additional-criteria"/>
        </properties>
    </persistence-unit>

    <!-- Advanced customer model persistence unit. -->
    <persistence-unit name="customer-pu" transaction-type="RESOURCE_LOCAL">
        <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
        <shared-cache-mode>NONE</shared-cache-mode>
        <class>org.eclipse.persistence.testing.models.jpa.advanced.customer.CustomerAddress</class>
        <class>org.eclipse.persistence.testing.models.jpa.advanced.customer.AddressType1</class>
        <class>org.eclipse.persistence.testing.models.jpa.advanced.customer.AddressType2</class>
        <class>org.eclipse.persistence.testing.models.jpa.advanced.customer.RegisteredCustomer</class>
        <exclude-unlisted-classes>true</exclude-unlisted-classes>
        <properties>
            <property name="eclipselink.logging.level" value="FINE" />
            <property name="eclipselink.logging.level.sql" value="FINEST"/>
            <property name="eclipselink.logging.level.cache" value="FINEST" />
            <property name="eclipselink.logging.parameters" value="true"/>
            <property name="eclipselink.ddl-generation" value="drop-and-create-tables" />
            <property name="eclipselink.ddl-generation.output-mode" value="database" />
        </properties>
    </persistence-unit>

</persistence>




/*******************************************************************************
 * Copyright (c) 2014 Oracle and/or its affiliates. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     jlamande    - Initial API and implementation
 *     Tomas Kraus - EclipseLink jUnit tests integration
 ******************************************************************************/
package org.eclipse.persistence.testing.models.jpa.advanced.customer;

import javax.persistence.Column;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

/**
 * First abstract {@link CustomerAddress} entity offspring.
 */
@Entity
@DiscriminatorValue("1")
public class AddressType1 extends CustomerAddress {

    /** Street name. */
    @Column(name="STREET1")
    private String street1;

    /**
     * Creates an instance of first {@link CustomerAddress} entity offspring. No entity attributes are set.
     */
    public AddressType1() {
    }

    /**
     * Creates an instance of first {@link CustomerAddress} entity offspring.
     * @param street Street name to be set.
     */
    public AddressType1(final String street) {
        street1 = street;
    }

    /**
     * Get street name.
     * @return Street name attribute value.
     */
    @Override
    public String getStreet() {
        return street1;
    }

    /**
     * Set street name.
     * @param street Street name to be set.
     */
    @Override
    public void setStreet(final String street) {
        street1 = street;
    }

    /**
     * Return first {@link CustomerAddress} entity offspring in human readable form.
     * @return Entity converted to {@link String} in human readable form.
     */
    @Override
    public String toString() {
        return "AddressType1 [" + street1 + "]";
    }

}




/*******************************************************************************
 * Copyright (c) 2014 Oracle and/or its affiliates. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     jlamande    - Initial API and implementation
 *     Tomas Kraus - EclipseLink jUnit tests integration
 ******************************************************************************/
package org.eclipse.persistence.testing.models.jpa.advanced.customer;

import javax.persistence.Column;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

/**
 * Second abstract {@link CustomerAddress} entity offspring.
 */
@Entity
@DiscriminatorValue("2")
public class AddressType2 extends CustomerAddress {

    /** Street name. */
    @Column(name="STREET2")
    private String street2;

    /**
     * Creates an instance of second {@link CustomerAddress} entity offspring. No entity attributes are set.
     */
    public AddressType2() {
    }

    /**
     * Creates an instance of second {@link CustomerAddress} entity offspring.
     * @param street Street name to be set.
     */
    public AddressType2(final String street) {
        this.street2 = street;
    }

    /**
     * Get street name.
     * @return Street name attribute value.
     */
    @Override
    public String getStreet() {
        return street2;
    }

    /**
     * Set street name.
     * @param street Street name to be set.
     */
    @Override
    public void setStreet(final String street) {
        street2 = street;
    }

    /**
     * Return secomd {@link CustomerAddress} entity offspring in human readable form.
     * @return Entity converted to {@link String} in human readable form.
     */
    @Override
    public String toString() {
        return "AddressType2 [" + street2 + "]";
    }
}




/*******************************************************************************
 * Copyright (c) 2014 Oracle and/or its affiliates. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Tomas Kraus - Initial API and implementation
 ******************************************************************************/
package org.eclipse.persistence.testing.models.jpa.advanced.customer;

import org.eclipse.persistence.testing.framework.TogglingFastTableCreator;
import org.eclipse.persistence.tools.schemaframework.TableDefinition;

// This table creator class is not used in the tests. Persistence unit shall create tables itself because of having
// eclipselink.ddl-generation value set to drop-and-create-tables.
// TODO: Resolve sequence / auto increment for primary keys. This is not implemented yet in this table creator.
/**
 * Advanced customer model table creator.
 */
public class AdvancedCustomerTableCreator extends TogglingFastTableCreator {

    /**
     * Build Address entity table definition including DiscriminatorColumn and offspring columns.
     * @return Address entity table definition.
     */
    public static TableDefinition buildAddressTable() {
        TableDefinition table = createTable("CMP3_AD_CU_ADDRESS");
        table.addField(createNumericPk("ID"));
        table.addField(createNumericColumn("TYPE", 1, false));
        table.addField(createStringColumn("STREET1"));
        table.addField(createStringColumn("STREET2"));
        return table;
    }

    /**
     * Build Customer entity table definition.
     * @return Customer entity table definition.
     */
    public static TableDefinition buildCustomerTable() {
        TableDefinition table = createTable("CMP3_AD_CU_ADDRESS");
        table.addField(createNumericPk("ID"));
        table.addField(createStringColumn("NAME", 1, false));
        table.addField(createNumericFk("ADDR_BA_ID", "ID"));
        table.addField(createNumericFk("ADDR_DA_ID", "ID"));
        return table;
    }

    /**
     * Crates an instance of advanced customer model table creator.
     * All model table definitions are registered.
     */
    public AdvancedCustomerTableCreator() {
        setName("EJB3AdvancedCustomerProject");
        addTableDefinition(buildAddressTable());
        addTableDefinition(buildCustomerTable());
    }

}




/*******************************************************************************
 * Copyright (c) 2014 Oracle and/or its affiliates. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     jlamande    - Initial API and implementation
 *     Tomas Kraus - EclipseLink jUnit tests integration
 ******************************************************************************/
package org.eclipse.persistence.testing.models.jpa.advanced.customer;

import javax.persistence.Column;
import javax.persistence.DiscriminatorColumn;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

/**
 * Abstract customer's address entity. 
 */
@Entity
@Table(name="CMP3_AD_CU_ADDRESS")
@Inheritance
@DiscriminatorColumn(name="TYPE",length=1)
@SequenceGenerator(name="CMP3_AD_CU_ADDRESS_ID_SEQ")
public abstract class CustomerAddress {

    /** Address primary key. */
	@Id
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="CMP3_AD_CU_ADDRESS_ID_SEQ")
	@Column(name="ID")
	private long id;

    /**
     * Get street name.
     * @return Street name attribute value.
     */
	public abstract String getStreet();

    /**
     * Set street name.
     * @param street Street name to be set.
     */
    public abstract void setStreet(final String street);

}




/*******************************************************************************
 * Copyright (c) 2014 Oracle and/or its affiliates. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     jlamande    - Initial API and implementation
 *     Tomas Kraus - EclipseLink jUnit tests integration
 ******************************************************************************/
package org.eclipse.persistence.testing.models.jpa.advanced.customer;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToOne;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

/**
 * Customer entity. 
 */
@Entity
@Table(name="CMP3_AD_CU_CUSTOMER")
@SequenceGenerator(name="CMP3_AD_CU_CUSTOMER_ID_SEQ")
@NamedQueries({
    @NamedQuery(name="RegisteredCustomer.selecAll",
            query="SELECT c FROM RegisteredCustomer c"),

    @NamedQuery(name="RegisteredCustomer.selecByName",
            query="SELECT c FROM RegisteredCustomer c"
                + " WHERE c.name = :name"),

    @NamedQuery(name="RegisteredCustomer.selecByNameFetch",
            query="SELECT c FROM RegisteredCustomer c"
                + "  LEFT JOIN FETCH c.deliveryAddress"
                + "  LEFT JOIN FETCH c.billingAddress"
                + " WHERE c.name = :name")
})
public class RegisteredCustomer {

    /** Customer primary key. */
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator="CMP3_AD_CU_CUSTOMER_ID_SEQ")
    @Column(name="ID")
    private long id;

    /** Customer name. */
    @Column(name="NAME")
    private String name;

    /** Customer billing address. */
    @OneToOne(cascade=CascadeType.ALL)
    @JoinColumn(name="ADDR_BA_ID", referencedColumnName="ID")
    private CustomerAddress billingAddress;

    /** Customer delivery address. */
    @OneToOne(cascade=CascadeType.ALL)
    @JoinColumn(name="ADDR_DA_ID", referencedColumnName="ID")
    private CustomerAddress deliveryAddress;

    /**
     * Creates an instance of {@code RegisteredCustomer} entity.
     * No entity attributes are set.
     */
    public RegisteredCustomer() {
    }

    /**
     * Creates an instance of {@code RegisteredCustomer} entity.
     * @param name            Customer name to be set.
     * @param billingAddress  Customer billing address to be set.
     * @param deliveryAddress Customer delivery address to be set.
     */
    public RegisteredCustomer(final String name, final CustomerAddress billingAddress,
            final CustomerAddress deliveryAddress) {
        this.name = name;
        this.billingAddress = billingAddress;
        this.deliveryAddress = deliveryAddress;
    }

    /**
     * Get Customer primary key.
     * @return Customer primary key attribute value.
     */
    public long getId() {
        return id;
    }

    /**
     * Get Customer name.
     * @return Customer name attribute value.
     */
    public String getName() {
        return name;
    }

    /**
     * Set Customer name.
     * @return Customer name to be set.
     */
    public void setName(final String name) {
        this.name = name;
    }

    /**
     * Get Customer billing address.
     * @return Customer billing address attribute value.
     */
    public CustomerAddress getBillingAddress() {
        return billingAddress;
    }

    /**
     * Set Customer billing address.
     * @param billingAddress Customer billing address to be set.
     */
    public void setBillingAddress(final CustomerAddress billingAddress) {
        this.billingAddress = billingAddress;
    }

    /**
     * Get Customer delivery address.
     * @return Customer delivery address attribute value.
     */
    public CustomerAddress getDeliveryAddress() {
        return deliveryAddress;
    }

    /**
     * Set Customer delivery address.
     * @param deliveryAddress Customer delivery address to be set.
     */
    public void setDeliveryAddress(final CustomerAddress deliveryAddress) {
        this.deliveryAddress = deliveryAddress;
    }

    /**
     * Return Customer entity in human readable form.
     * @return Entity converted to {@link String} in human readable form.
     */
    @Override
    public String toString() {
        return "RegisteredCustomer [" + id + "," + name + "," + billingAddress + "," + deliveryAddress + "]";
    }

}




/*******************************************************************************
 * Copyright (c) 2014 Oracle and/or its affiliates. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     jlamande    - Initial API and implementation
 *     Tomas Kraus - EclipseLink jUnit tests integration
 ******************************************************************************/
package org.eclipse.persistence.testing.tests.jpa.advanced;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.Query;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.JoinType;
import javax.persistence.criteria.Root;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;
import org.eclipse.persistence.testing.models.jpa.advanced.AdvancedTableCreator;
import org.eclipse.persistence.testing.models.jpa.advanced.customer.CustomerAddress;
import org.eclipse.persistence.testing.models.jpa.advanced.customer.AddressType1;
import org.eclipse.persistence.testing.models.jpa.advanced.customer.AddressType2;
import org.eclipse.persistence.testing.models.jpa.advanced.customer.AdvancedCustomerTableCreator;
import org.eclipse.persistence.testing.models.jpa.advanced.customer.RegisteredCustomer;

/**
 * Runs tests on advanced customer model with Customer entity having two abstract Addresses. Each of those addresses
 * may contain instances of different offspring. Address entities are mapped into a single table using
 * {@code DiscriminatorColumn} to distinguish them.
 */
public class AbstractEntityWithColumnDiscriminatorTest extends JUnitTestCase {

    /** {@link RegisteredCustomer} entity name attribute value. */
    private static final String CUSTOMER_NAME = "JONES";

    /** Value of {@code billingAddress} entity street attribute. */
    private static final String CUSTOMER_ADDR_BILLING = "STREET1";

    /** Value of {@code deliveryAddress} entity street attribute. */
    private static final String CUSTOMER_ADDR_DELIVERY = "STREET2";


    /** Persistence unit name. */
    private static final String PU_NAME = "customer-pu";

    /**
     * Build collection of test cases for this jUnit test instance.
     * @return {@link Test} class containing collection of test cases for this jUnit test instance.
     */
    public static Test suite() {
        final TestSuite suite = new TestSuite();
        suite.addTest(new AbstractEntityWithColumnDiscriminatorTest("testSetup"));
        addNamedQueryTests(suite);
        suite.addTest(new AbstractEntityWithColumnDiscriminatorTest("testCleanup"));
        return suite;
    }

    /**
     * Adds test, similar to suite() but without adding a setup and cleanup. Used from {@code suite()} to add individual
     * tests.
     * @param suite Target {@link TestSuite} class where to store tests.
     * @return {@link Test} class containing collection of test cases for this jUnit test instance.
     */
    public static Test addNamedQueryTests(final TestSuite suite){
        suite.setName("NamedQueryJUnitTest");
        suite.addTest(new AbstractEntityWithColumnDiscriminatorTest("testJpqlNoFetch"));
        suite.addTest(new AbstractEntityWithColumnDiscriminatorTest("testJpqlFetch"));
        suite.addTest(new AbstractEntityWithColumnDiscriminatorTest("testCriteriaNoFetch"));
        suite.addTest(new AbstractEntityWithColumnDiscriminatorTest("testCriteriaFetch"));
        return suite;
    }

    /**
     * Create {@link RegisteredCustomer} entity instance with {@code billingAddress} set to {@link AddressType1}
     * instance and {@code deliveryAddress} set to {@link AddressType2} instance. Entity is persisted.
     * @param em An {@link EntityManager} instance used to persist entities.
     */
    private static void createCustomer(final EntityManager em) {
        em.getTransaction().begin();
        try {
            final RegisteredCustomer cus = new RegisteredCustomer(CUSTOMER_NAME, new AddressType1(
                    CUSTOMER_ADDR_BILLING), new AddressType2(CUSTOMER_ADDR_DELIVERY));
            em.persist(cus);
            em.getTransaction().commit();
        } catch (Throwable e) {
            em.getTransaction().rollback();
            throw e;
        }
    }

    /**
     * Delete all {@link RegisteredCustomer} entities.
     * @param em An {@link EntityManager} instance used to persist entities.
     */
    private static void deleteAllCustomers(final EntityManager em) {
        List<RegisteredCustomer> customers = em.createNamedQuery(
                "RegisteredCustomer.selecAll", RegisteredCustomer.class).getResultList();
        em.getTransaction().begin();
        try {
            for (RegisteredCustomer cus : customers) {
                em.remove(cus);
            }
            em.getTransaction().commit();
        } catch (Throwable e) {
            em.getTransaction().rollback();
            throw e;
        }
    }

    /**
     * Validate {@link RegisteredCustomer} entity instance.
     * @param customer {@link RegisteredCustomer} entity instance to be validated.
     */
    private static void assertCustomer(final RegisteredCustomer customer) {
        assertEquals(CUSTOMER_NAME, customer.getName());
        assertTrue(customer.getBillingAddress() instanceof AddressType1);
        assertEquals(CUSTOMER_ADDR_BILLING, ((AddressType1) customer.getBillingAddress()).getStreet());
        assertTrue(customer.getDeliveryAddress() instanceof AddressType2);
        assertEquals(CUSTOMER_ADDR_DELIVERY, ((AddressType2) customer.getDeliveryAddress()).getStreet());
    }

    /**
     * Constructs an instance of {@code AbstractEntityWithColumnDiscriminatorTest} class.
     */
    public AbstractEntityWithColumnDiscriminatorTest() {
        super();
    }

    /**
     * Constructs an instance of {@code AbstractEntityWithColumnDiscriminatorTest} class with given test case name.
     * @param name Test case name.
     */
    public AbstractEntityWithColumnDiscriminatorTest(final String name) {
        super(name);
        setPuName(PU_NAME);
    }

    /**
     * Initial setup is done as first test in collection, both to record its failure, and to allow execution
     * in the server.
     */
    public void testSetup() {
        // Table creator shall not be used for this persistence unit.
        // new AdvancedCustomerTableCreator().replaceTables(getServerSession(PU_NAME));
        clearCache(PU_NAME);
        final EntityManager em = createEntityManager(PU_NAME);
        try {
            createCustomer(em);
        } finally {
            em.close();
        }
    }

    /**
     * Final cleanup is done as last test in collection, both to record its failure, and to allow execution
     * in the server.
     */
    public void testCleanup() {
        final EntityManager em = createEntityManager(PU_NAME);
        try {
            deleteAllCustomers(em);
        } finally {
            em.close();
        }
    }

    /**
     * Test JPQL query on {@link RegisteredCustomer} without {@code LEFT JOIN FETCH} of {@link CustomerAddress}
     * entities.
     */
    public void testJpqlNoFetch() {
        final EntityManager em = createEntityManager(PU_NAME);
        try {
            final Query query = em.createNamedQuery(
                    "RegisteredCustomer.selecByName",
                    RegisteredCustomer.class).setParameter("name", CUSTOMER_NAME);
            final RegisteredCustomer customer = (RegisteredCustomer) query.getSingleResult();
            assertCustomer(customer);
        } finally {
            em.close();
        }
    }

    /**
     * Test JPQL query on {@link RegisteredCustomer} with {@code LEFT JOIN FETCH} of {@link CustomerAddress} entities.
     */
    public void testJpqlFetch() {
        final EntityManager em = createEntityManager(PU_NAME);
        try {
            final Query query = em.createNamedQuery(
                    "RegisteredCustomer.selecByNameFetch",
                    RegisteredCustomer.class).setParameter("name", CUSTOMER_NAME);
            final RegisteredCustomer customer = (RegisteredCustomer) query.getSingleResult();
            assertCustomer(customer);
        } finally {
            em.close();
        }
    }

    /**
     * Test criteria query on {@link RegisteredCustomer} without {@code LEFT JOIN FETCH} of {@link CustomerAddress}
     * entities.
     */
    public void testCriteriaNoFetch() {
        final EntityManager em = createEntityManager(PU_NAME);
        try {
            final CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
            final CriteriaQuery<RegisteredCustomer> criteriaQuery
                    = criteriaBuilder.createQuery(RegisteredCustomer.class);
            final Root<RegisteredCustomer> from = criteriaQuery.from(RegisteredCustomer.class);

            criteriaQuery.where(criteriaBuilder.equal(from.get("name"), CUSTOMER_NAME));
            criteriaQuery.distinct(true);

            final TypedQuery<RegisteredCustomer> query = em.createQuery(criteriaQuery);
            final RegisteredCustomer customer = query.getSingleResult();
            assertCustomer(customer);
        } finally {
            em.close();
        }
    }

    /**
     * Test criteria query on {@link RegisteredCustomer} with {@code LEFT JOIN FETCH} of {@link CustomerAddress}
     * entities.
     */
    public void testCriteriaFetch() {
        final EntityManager em = createEntityManager(PU_NAME);
        try {
            final CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
            final CriteriaQuery<RegisteredCustomer> criteriaQuery
                    = criteriaBuilder.createQuery(RegisteredCustomer.class);
            final Root<RegisteredCustomer> from = criteriaQuery.from(RegisteredCustomer.class);

            from.fetch("billingAddress", JoinType.LEFT);
            from.fetch("deliveryAddress", JoinType.LEFT);

            criteriaQuery.where(criteriaBuilder.equal(from.get("name"), CUSTOMER_NAME));
            criteriaQuery.distinct(true);

            final TypedQuery<RegisteredCustomer> query = em.createQuery(criteriaQuery);
            final RegisteredCustomer customer = query.getSingleResult();
            assertCustomer(customer);
        } finally {
            em.close();
        }
    }

}

Return to bug 395738

Lines 403-406 Link Here

(-)a/jpa/eclipselink.jpa.test/resource/eclipselink-annotation-model/persistence.xml (+20 lines)
403	<property name="eclipselink.validation-only" value="true"/>	403	<property name="eclipselink.validation-only" value="true"/>
404	</properties>	404	</properties>
405	</persistence-unit>	405	</persistence-unit>
		406
		407	<!-- Advanced customer model persistence unit. -->
		408	<persistence-unit name="customer-pu" transaction-type="RESOURCE_LOCAL">
		409	<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
		410	<shared-cache-mode>NONE</shared-cache-mode>
		411	<class>org.eclipse.persistence.testing.models.jpa.advanced.customer.CustomerAddress</class>
		412	<class>org.eclipse.persistence.testing.models.jpa.advanced.customer.AddressType1</class>
		413	<class>org.eclipse.persistence.testing.models.jpa.advanced.customer.AddressType2</class>
		414	<class>org.eclipse.persistence.testing.models.jpa.advanced.customer.RegisteredCustomer</class>
		415	<exclude-unlisted-classes>true</exclude-unlisted-classes>
		416	<properties>
		417	<property name="eclipselink.logging.level" value="FINE" />
		418	<property name="eclipselink.logging.level.sql" value="FINEST"/>
		419	<property name="eclipselink.logging.level.cache" value="FINEST" />
		420	<property name="eclipselink.logging.parameters" value="true"/>
		421	<property name="eclipselink.ddl-generation" value="drop-and-create-tables" />
		422	<property name="eclipselink.ddl-generation.output-mode" value="database" />
		423	</properties>
		424	</persistence-unit>
		425
406	</persistence>	426	</persistence>

Lines 216-219 Link Here

(-)a/jpa/eclipselink.jpa.test/resource/eclipselink-annotation-model/spring/persistence.xml (+20 lines)
216	<property name="eclipselink.session-name" value="additional-criteria"/>	216	<property name="eclipselink.session-name" value="additional-criteria"/>
217	</properties>	217	</properties>
218	</persistence-unit>	218	</persistence-unit>
		219
		220	<!-- Advanced customer model persistence unit. -->
		221	<persistence-unit name="customer-pu" transaction-type="RESOURCE_LOCAL">
		222	<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
		223	<shared-cache-mode>NONE</shared-cache-mode>
		224	<class>org.eclipse.persistence.testing.models.jpa.advanced.customer.CustomerAddress</class>
		225	<class>org.eclipse.persistence.testing.models.jpa.advanced.customer.AddressType1</class>
		226	<class>org.eclipse.persistence.testing.models.jpa.advanced.customer.AddressType2</class>
		227	<class>org.eclipse.persistence.testing.models.jpa.advanced.customer.RegisteredCustomer</class>
		228	<exclude-unlisted-classes>true</exclude-unlisted-classes>
		229	<properties>
		230	<property name="eclipselink.logging.level" value="FINE" />
		231	<property name="eclipselink.logging.level.sql" value="FINEST"/>
		232	<property name="eclipselink.logging.level.cache" value="FINEST" />
		233	<property name="eclipselink.logging.parameters" value="true"/>
		234	<property name="eclipselink.ddl-generation" value="drop-and-create-tables" />
		235	<property name="eclipselink.ddl-generation.output-mode" value="database" />
		236	</properties>
		237	</persistence-unit>
		238
219	</persistence>	239	</persistence>

Added Link Here

(-)a/jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/models/jpa/advanced/customer/AddressType1.java (+72 lines)
1	/*******************************************************************************
2	* Copyright (c) 2014 Oracle and/or its affiliates. All rights reserved.
3	* This program and the accompanying materials are made available under the
4	* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
5	* which accompanies this distribution.
6	* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
7	* and the Eclipse Distribution License is available at
8	* http://www.eclipse.org/org/documents/edl-v10.php.
9	*
10	* Contributors:
11	* jlamande - Initial API and implementation
12	* Tomas Kraus - EclipseLink jUnit tests integration
13	******************************************************************************/
14	package org.eclipse.persistence.testing.models.jpa.advanced.customer;
15
16	import javax.persistence.Column;
17	import javax.persistence.DiscriminatorValue;
18	import javax.persistence.Entity;
19
20	/**
21	* First abstract {@link CustomerAddress} entity offspring.
22	*/
23	@Entity
24	@DiscriminatorValue("1")
25	public class AddressType1 extends CustomerAddress {
26
27	/** Street name. */
28	@Column(name="STREET1")
29	private String street1;
30
31	/**
32	* Creates an instance of first {@link CustomerAddress} entity offspring. No entity attributes are set.
33	*/
34	public AddressType1() {
35	}
36
37	/**
38	* Creates an instance of first {@link CustomerAddress} entity offspring.
39	* @param street Street name to be set.
40	*/
41	public AddressType1(final String street) {
42	street1 = street;
43	}
44
45	/**
46	* Get street name.
47	* @return Street name attribute value.
48	*/
49	@Override
50	public String getStreet() {
51	return street1;
52	}
53
54	/**
55	* Set street name.
56	* @param street Street name to be set.
57	*/
58	@Override
59	public void setStreet(final String street) {
60	street1 = street;
61	}
62
63	/**
64	* Return first {@link CustomerAddress} entity offspring in human readable form.
65	* @return Entity converted to {@link String} in human readable form.
66	*/
67	@Override
68	public String toString() {
69	return "AddressType1 [" + street1 + "]";
70	}
71
72	}