Skip to main content
Jump to: navigation, search

Dali Developer Documentation

Revision as of 14:43, 13 September 2013 by (Talk | contribs) (Terminology)


NB: Ensure the Eclipse network proxy is configured, if applicable (Preferences > General > Network Connections)

Development Workspace

To set up an Eclipse IDE workspace for working on Dali, perform the following steps:

eclipse.exe -vm C:\jdk\1.6.0_23\bin\javaw.exe -data C:\dev\dali -vmargs -Xmx768M -XX:MaxPermSize=256M
  • Add the appropriate Execution Environment to the host platform
    • If necessary, download and install the final J2SE 1.5 JRE or JDK (
    • Start the host platform
    • Add an Installed JRE (Preferences > Java > Installed JREs)
      • <Standard VM>
      • Select the directory holding the just-installed JRE/JDK
    • NB: This Java installation must be version 1.5. Installing and using a 1.5 JRE/JDK reduces the possibility of any errors slipping through (e.g. using classes or methods added in later versions of Java). The host platform can be run on a later version of Java; but the Dali plug-ins must be compiled against and capable of executing on Java 1.5. Each Dali project's build path and project-specific Java compiler settings ensure Dali is compiled with Java 1.5 compliance; but there must be a Java 1.5 installation present for the compiler to compile against the correct Java jars.
    • NB: As of the Luna release, parts of the Eclipse Platform needed by Dali require a Java 1.6 Execution Environment. As a result, Dali requires a Java 1.6 Execution Environment to execute. Despite this requirement, Dali will continue to be compiled against and require only a Java 1.5 Execution Environment, until an irresistable Java feature compels Dali to move to a higher version of Java.
  • Set up a target platform
    • Download the latest WTP Integration Build and all of its dependencies (
      • Eclipse SDK
      • EMF and XSD SDK
      • GEF SDK
      • DTP SDK
      • EMF Transaction
      • EMF Validation
      • Graphiti
      • Orbit
      • WTP SDK
    • Unzip all the downloaded files (except the Graphiti and Orbit files) into the same directory (This directory is different than the directory holding the host platform created above.)
  • Configure the host platform to use the target platform for building plug-ins
    • Start the host platform
    • Add a target platform (Preferences > Plug-in Development > Target Platform)
      • <Add...> a new Target definition
      • Initialize the target definition with <Nothing>
      • <Add...> a new location for the target platform
        • <Directory>
        • Select the directory holding the target platform (i.e. the directory holding the just-unzipped WTP files and pre-requisites)
        • NB: The new location should indicate it has over 1000 plug-ins available
      • <Add...> another location for the Orbit repository
        • <Software Site>
        • <Add...> a new repository
          • <Archive...>
          • Select the just-downloaded Orbit zip file
        • <Work with:> the just-added Orbit repository
        • NB: Make sure <Group by Category> is checked.
        • Select "All Orbit Bundles" => "EasyMock"
        • NB: The new location should indicate it has 2 plug-ins available
      • <Add...> another location for the Graphiti repository
        • <Software Site>
        • <Add...> a new repository
          • <Archive...>
          • Select the just-downloaded Graphiti zip file
        • <Work with:> the just-added Graphiti repository
        • NB: Make sure <Include required software> is unchecked. (Graphiti requires the EMF Transaction plug-in, which is already part of the target platform location added above.)
        • Select "Graphiti SDK" (or "Graphiti" => "Graphiti SDK" if grouped by categories.)
        • NB: The new location should indicate it has 20 plug-ins available
      • <Finish> the wizard to create the new target platform
  • Optional (but very helpful): Configure the host platform to include the classes from the target platform (Preferences > Plug-in Development > Include all plug-ins from target in Java search)
  • Clone the Eclipse Foundation-hosted Dali Git repository and import the Dali projects
    • Ensure the Eclipse network proxy is configured, if applicable (Preferences > General > Network Connections)
    • Open the Git Repository Exploring perspective
    • Clone the Dali repository using the appropriate URL from
    • Import the plug-in and test plug-in projects in the repository's working directory (The projects are named org.eclipse.jpt.*.):
      • common/plugins - the *.branding projects are optional
      • common/tests
      • jaxb/plugins - the *.branding projects are optional
      • jaxb/tests
      • jpa/plugins - the *.branding projects are optional
      • jpa/tests
      • jpa_diagram_editor/plugins
      • jpa_diagram_editor/tests

JUnit Tests

Once the development workspace is configured and the Dali plug-ins built, it is possible to execute the Dali tests.

Generic JPA Core Tests

  • Add a run configuration (Run > Run Configurations... > JUnit Plug-in Test > New)
    • <Test> tab
      • <Run a single test>
        • Project: org.eclipse.jpt.jpa.core.tests
        • Test Class: org.eclipse.jpt.jpa.core.tests.internal.JptJpaCoreTests
      • Test Runner: JUnit 3 or 4
    • <Main> tab
      • <Program to run>
        • Run an application: [No Application] - Headless mode
    • <Arguments> tab
      • VM arguments:
-Dorg.eclipse.jpt.jpa.jar=<path to jar containing javax.persistence packages>
  • <Run>

NB: These tests may take on the order of 30 minutes to complete.

EclipseLink JPA Core Tests

Duplicate the Generic JPA Core Tests configuration described above and make the following modifications:

  • <Test> tab
    • Project: org.eclipse.jpt.jpa.eclipselink.core.tests
    • Test class: org.eclipse.jpt.jpa.eclipselink.core.tests.internal.JptJpaEclipseLinkCoreTests
  • <Arguments> tab
    • Add the following VM argument:
-Dorg.eclipse.jpt.eclipselink.jar=<path to eclipselink.jar>

Generic JAXB Core Tests

Duplicate the Generic JPA Core Tests configuration described above and make the following modifications:

  • <Test> tab
    • Project: org.eclipse.jpt.jaxb.core.tests
    • Test class: org.eclipse.jpt.jaxb.core.tests.internal.JaxbCoreTests
  • <Arguments> tab
    • Add the following VM argument:
-Dorg.eclipse.jpt.jaxb.jar=<path to eclipselink.jar>

EclipseLink JAXB Core Tests

Duplicate the Generic JAXB Core Tests configuration described above and make the following modifications:

  • <Test> tab
    • Project: org.eclipse.jpt.jaxb.eclipselink.core.tests
    • Test class: org.eclipse.jpt.jaxb.eclipselink.core.tests.internal.ELJaxbCoreTests
  • <Arguments> tab
    • Add the following VM argument:
-Dorg.eclipse.jpt.jaxb.jar=<path to eclipselink.jar>
-Dorg.eclipse.jpt.eclipselink.jar=<path to eclipselink.jar>

Common Core Tests

Duplicate the Generic JPA Core Tests configuration described above and make the following modifications:

  • <Test> tab
    • Project: org.eclipse.jpt.common.core.tests
    • Test class: org.eclipse.jpt.common.core.tests.internal.JptCommonCoreTests

Common Utility Tests

  • Add a run configuration (Run > Run Configurations... > JUnit > New)
    • <Test> tab
      • <Run a single test>
        • Project: org.eclipse.jpt.common.utility.tests
        • Test Class: org.eclipse.jpt.common.utility.tests.internal.JptCommonUtilityTests

Other Tests

There are a number of other test suites that should be reasonably straightforward to configure:

  • Common UI
  • Generic JPA UI
  • Generic JPA Generation
  • JPA Diagram Editor

Major User Features

JPA Structure View

The JPA Structure View is much like the standard Eclipse Outline View; it is associated with the current editor's file and is an outline of the JPA model corresponding to the file's JPA content. The JPA Structure View is active only for files in JPA projects (i.e. projects with a JPA Facet). Typical files:

  • the project's META-INF/persistence.xml file
  • any mapping (typically orm.xml) files referenced by the persistence.xml file
  • any Java files with JPA annotations

JPA Details View

The JPA Details View provides a rich UI for the editing of JPA-related metadata. It provides the user with all the settings appropriate for the current state of the current selection. It also displays all the JPA spec-defined defaults for each setting. The JPA Details View also attempts to provide a similar set of settings for both Java and orm.xml mappings.


Like the Java compiler, every time the user saves a file Dali will validate the file's JPA project. In particular, Dali validates the project's JPA settings against a user-specified database and generates Eclipse "Problems" for any settings that do not match the database's metadata. The severity of these errors can be configured by the user in the workspace and/or project-specific preferences.

JPQL content assistance

Dali provides content assistance for JPQL queries edited in a Java source file, an orm.xml file, or the JPA Details View.

Entity generation from tables

Dali can generate JPA spec-compliant Entities from tables defined in a DTP-accessible database.

Canonical metamodel generation

As of JPA 2.0, Dali can be configured to dynamically generate JPA spec-compliant Canonical Metamodel classes based on the current state of a JPA project. This happens continuously, as the user edits JPA Entities etc. This allows the user to immediately use the current Entities etc. in the Criteria API, without waiting for the invocation of an external Annotation Processor. (In particular, Dali will re-generate the Canonical Metamodel with changes to the various JPA XML files; while, typically, annotation processors will not detect changes to XML files.) This generation will also reveal, immediately, as the Entities etc. are changed, any errors in existing usages of the Criteria API.

Design Terminology

Resource Model: A resource model directly reflects a given resource (Java source or XML source). Dali currently maintains three resource models, including one for persistence.xml, the XML mapping file(s), and one for JPA Annotations. For XML resources(Mapping File or persistence.xml) this is a generated EMF model that uses the WTP translator framework to read/write the XML source. On the Java side it is a non-EMF object model that represents the JPA Annotations on the Java Types and Attributes.

Context Model: A context model represents only the non-resource related JPA metadata. Dali currently maintains three context models, including one for persistence.xml, the XML mapping file(s), and one for JPA Annotations. It pulls together the persistence.xml, XML Mapping File and Java resource models and uses common API. As and example, it gives context to the Java Annotations so that a JavaResourcePersistentType in the resource model with Entity, Table, SecondaryTable annotations on it becomes a PersistentType with an Entity TypeMapping in the context model. The context model interfaces are used by the Dali UI and adopters.

Persistent Type: Any Java Type that will be persisted.

Persistent Attribute: Any Java Attribute that will be persisted.

Mapping: A collection of related JPA metadata that consists of a persistence strategy for a given Type or Attribute.

Type Mapping: A specific way of persisting a Persistent Type, for example, Enity, Mapped Superclass, or Embeddable. All JPA metadata specified at the Type level will be contained by this Type Mapping.

Attribute Mapping: A specific way of persisting a Persistent Attribute, for example, Basic, ManyToOne, or OneToMany. All JPA metadata specified at the Attribute level will be contained by this Attribute Mapping.

Model usage examples

Traversing the Context model for JPA metadata

To access the JPA metadata for a type listed in the persistence.xml file:

IProject.getAdapter(JpaProject.class) : JpaProject
  JpaProject.getRootContextNode() : JpaRootContextNode
    JpaRootContextNode.getPersistenceXml(): PersistenceXml
      PersistenceXml.getPersistence() : Persistence
        Persistence.getPersistenceUnits() : Iterable<PersistenceUnit>
              (this will contain 0 or 1 PersistenceUnits as Dali does not support multiple persistence units)
          PersistenceUnit.getClassRefs() : Iterable<ClassRef>
            ClassRef.getJavaPersistentType() : JavaPersistentType
              JavaPersistentType.getMapping() : JavaTypeMapping
              JavaPersistentType.getAttributes() : Iterable<JavaPersistentAttribute>
                JavaPersistentAttribute.getMapping() : JavaAttributeMapping

To access the JPA metadata for a type listed in an orm.xml file:

PersistenceUnit.getMappingFileRefs() : Iterable<MappingFileRef>
  MappingFileRef.getMappingFile() : MappingFile
    MappingFile.getPersistentTypes() : Iterable<PersistentType>

Retrieving the JPA Entities for a Project

public static Iterable<PersistentType> getEntities(IProject project) {
    JpaProject jpaProject = (JpaProject) project.getAdapter(JpaProject.class);
    if (jpaProject == null) {
        return Collections.emptySet();

    JpaRootContextNode rootContextNode = jpaProject.getRootContextNode();
    PersistenceXml persistenceXml = rootContextNode.getPersistenceXml();
    if (persistenceXml == null) {
        return Collections.emptySet();

    Persistence persistence = persistenceXml.getPersistence();
    if (persistence == null) {
        return Collections.emptySet();

    if (persistence.getPersistenceUnitsSize() == 0) {
        return Collections.emptySet();

    PersistenceUnit persistenceUnit = persistence.getPersistenceUnit(0);
    ArrayList<PersistentType> entities = new ArrayList<PersistentType>();
    for (PersistentType persistentTypes : persistenceUnit.getPersistentTypes()) {
        if (persistentTypes.getMappingKey() == MappingKeys.ENTITY_TYPE_MAPPING_KEY) {
    return entities;

Changing the Context model programatically

If you are changing the model outside the UI thread you will need to configure the JPA project to make modifications on the UI thread as necessary. See JpaProject#setThreadLocalModifySharedDocumentCommandExecutor(CommandExecutor).

Also note the model is "updated" asynchronously with every change. If you want these updates to happen synchronously, you will need to set the JPA project's "updater". See JpaProject#setUpdater(Updater). Note the comments in SynchronousJpaProjectUpdater.

Core Dali Plug-ins


Description: Resource model and Context model interfaces and implementations


Description: DTP wrapper model, serves as Dali’s interface to the DTP DB model.


Description: Dali UI for DTP Connection Wizard


Description: Javadoc plugin


Description: User docs and infopop for Dali


Description: Contains model and generator code for generating Entities from tables


Description: Contains the actions, composites, data models, wizards, views, and perspective that make up the Dali UI.


Description: A set of utility classes for the Dali plug-in. Contains a set of advanced iterators, change support, SWT Value Models, plus utilities for dealing with Files, Strings, Collections, etc.

No Dependencies.


Description: EclipseLink extension, including an EclipseLinkPlatform and the EclipseLink context model.


Description: EclipseLink UI extension, including an EclipseLinkPlatformUI and associated EclipseLink UI composites.


Description: Contains a suite of headless JUnit tests for the core plug-ins.


Description: Contains a comprehensive set of tests for the Utility classes.

Major Integration points


  • The Dali Core makes extensive use of the JDT Core model and utilities for the purpose of reading and writing Java class metadata.
  • Code Completion



The Dali DB and DDL plug-ins make use of the data definition mode and the New Connection Wizard. The Datasource Explorer view is an integral part of the Dali Persistence Perspective.


  • Facets
  • EMF-XML Translator Framework
  • Validation Framework


  • Project Explorer


Dali's main extension mechanism is the JpaPlatform Interface and extension point.

This interface is to be implemented by a JPA vendor to provide extensions to the core JPA model. The core JPA model will provide functionality for JPA spec annotations in java, persistence.xml and (orm.xml) mapping files. The org.eclipse.jpt.core.genericPlatform extension supplies resource models for those file types. As another vendor option you will have to supply those resource models as well or different ones as necessary.

The extension designates a Platform ID, Label, Class (implemenation of JpaPlatform), and an option to set the platform as a "Default" platform.

Extension Example:


See the EclipseLinkPlatform included in Dali as an exemplary implementation.


Provisional API is available as of the 2.0 release.



Back to the top