Sun Java System Application Server Enterprise Edition 8.1 2005Q2 Performance Tuning Guide

- Previous: Read-Only Entity Beans
- Next: JDBC and Database Access

### Pre-fetching Container Managed Relationship (CMR) Beans

If a container-managed relationship (CMR) exists in your application, loading one bean will load all its related beans. The canonical example of CMR is an order-orderline relationship where you have one Order EJB component that has related OrderLine EJB components. In previous releases of the application server, to use all those beans would require multiple database queries: one for the Order bean and one for each of the OrderLine beans in the relationship.

In general, if a bean has n relationships, using all the data of the bean would require n+1 database accesses. Use CMR pre-fetching to retrieve all the data for the bean and all its related beans in one database access.

For example, you have this relationship defined in the `ejb-jar.xml` file:

    <relationships>
        <ejb-relation>
            <description>Order-OrderLine</description>
            <ejb-relation-name>Order-OrderLine</ejb-relation-name>
            <ejb-relationship-role>
                <ejb-relationship-role-name>
                    Order-has-N-OrderLines
                </ejb-relationship-role-name>
                <multiplicity>One</multiplicity>
                <relationship-role-source>
                    <ejb-name>OrderEJB</ejb-name>
                </relationship-role-source>
                <cmr-field>
                    <cmr-field-name>orderLines</cmr-field-name>
                    <cmr-field-type>java.util.Collection</cmr-field-type>
                </cmr-field>
            </ejb-relationship-role>
        </ejb-relation>
    </relationships>

When a particular Order is loaded, you can load its related OrderLines by adding this to the `sun-cmp-mapping.xml` file for the application:

    <entity-mapping>
        <ejb-name>Order</ejb-name>
        <table-name>...</table-name>
        <cmp-field-mapping>...</cmp-field-mapping>
        <cmr-field-mapping>
            <cmr-field-name>orderLines</cmr-field-name>
            <column-pair>
                <column-name>OrderTable.OrderID</column-name>
                <column-name>OrderLineTable.OrderLine_OrderID</column-name>
            </column-pair>
            <fetched-with>
                <default>
            </fetched-with>
        </cmr-field-mapping>
    </entity-mappping>

Now when an Order is retrieved, the CMP engine issues SQL to retrieve all related OrderLines with a SELECT statement that has the following WHERE clause:

    OrderTable.OrderID = OrderLineTable.OrderLine_OrderID

This clause indicates an outer join. These OrderLines are pre-fetched.

Pre-fetching generally improves performance because it reduces the number of database accesses. However, if the business logic often uses Orders without referencing their OrderLines, then this can have a performance penalty, that is, the system has spent the effort to pre-fetch the OrderLines that are not actually needed.

Avoid pre-fetching for specific finder methods; this can often avoid that penalty. For example, consider an order bean has two finder methods: a `findByPrimaryKey` method that uses the orderlines, and a `findByCustomerId` method that returns only order information and hence doesn’t use the orderlines. If you’ve enabled CMR pre-fetching for the orderlines, both finder methods will pre-fetch the orderlines. However, you can prevent pre-fetching for the `findByCustomerId` method by including this information in the `sun-ejb-jar.xml` descriptor:

    <ejb>
        <ejb-name>OrderBean</ejb-name>
        ...
        <cmp>
            <prefetch-disabled>
                <query-method>
                    <method-name>findByCustomerId</method-name>
                </query-method>
            </prefetch-disabled>
         </cmp>
    </ejb>

- Previous: Read-Only Entity Beans
- Next: JDBC and Database Access

- © 2010, Oracle Corporation and/or its affiliates