Difference between revisions of "Configuring a Relational Many-to-Many Mapping (ELUG)"

Revision as of 16:42, 14 December 2007

This section describes the various components that you must configure in order to use a relational many-to-many mapping.

For information on how to configure EclipseLink mappings options common to two or more mapping types, see Configuring a Mapping.

For information on how to create EclipseLink mappings, see Creating a Mapping.

This table lists the configurable options for a relational many-to-many mapping.

This example shows how to create a many-to-many mapping and add it to a descriptor using Java code.

Many-to-Many Mapping

public void customize(ClassDescriptor descriptor) { 
    ManyToManyMapping mapping = new ManyToManyMapping();  

    // configure mapping
    ... 

    // add mapping to descriptor
    descriptor.addMapping(mapping);
}

For more information, see the following:

• Many-to-Many Mapping
• Configuring a Relational Mapping
• Creating and Configuring Mappings

For information on using JPA to configure many-to-many mappings, see @ManyToMany.

Configuring a Relation Table

The relation table contains the columns for the primary keys of the source table and target table involved in the many-to-many mapping. You must create this table in the database before completing the mapping. See Using Databases for information on creating database tables.

In the Many-to-many Relationships figure, the PROJ_EMP table serves as the relation table between the PROJECT and EMPLOYEE tables.

How to Configure a Relation Table Using Workbench

To select a relation table for a mapping, use this procedure:

1. Select the mapped attribute in the Navigator. Its properties appear in the Editor.
2. Click the General tab. The General tab appears.
   Table Reference Tab, Relation Table Option
   
3. Use the Relation Table field to select a database table to define this mapping.

How to Configure a Relation Table Using Java

Many-to-many mappings represent the relationships between a collection of source objects and a collection of target objects. This requires an intermediate table that manages the associations between the source and target records.

Many-to-many mappings are instances of the ManyToManyMapping class and requires the following elements:

• The attribute mapped, set by using the setAttributeName method.
• The reference class, set by using the setReferenceClass method.
• The relation table, set by using the setRelationTableName() method.
• The foreign key information (for noncomposite target primary keys), which you specify by calling the setSourceRelationKeyFieldName and setTargetRelationKeyFieldName methods.
• The foreign key information if the source or target primary keys are composite, which you specify by sending the addSourceRelationKeyFieldName or addTargetRelationKeyFieldName methods.

Configuring a Relational Table

public void customize(ClassDescriptor descriptor) { 
    // In the Employee class, create the mapping that references Project class
    ManyToManyMapping manyToManyMapping = new ManyToManyMapping();
    manyToManyMapping.setAttributeName("projects");
    manyToManyMapping.setReferenceClass(Project.class);

    // Configure the relational table
    manyToManyMapping.setRelationTableName("PROJ_EMP");
    manyToManyMapping.setSourceRelationKeyFieldName ("EMPID");
    manyToManyMapping.setTargetRelationKeyFieldName ("PROJID");

    // Add mapping to descriptor

    descriptor.addMapping(manyToManyMapping);
}

In addition to the API that Configuring a Relational Table illustrates, other common API for use with many-to-many mappings include the following:

• useBasicIndirection: implements EclipseLink value holder indirection.
• useTransparentCollection: if you use transparent indirection, this element places a special collection in the source object's attribute.
• dontUseIndirection: implements no indirection.

For more information about the available methods for ManyToManyMapping, see the EclipseLink API Reference.

Copyright Statement