diff --git a/jpa-moxy/jpa-moxy.simple/.classpath b/jpa-moxy/jpa-moxy.simple/.classpath
index 698778f..dcfd78b 100644
--- a/jpa-moxy/jpa-moxy.simple/.classpath
+++ b/jpa-moxy/jpa-moxy.simple/.classpath
@@ -17,14 +17,14 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7">
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7">
 		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="owner.project.facets" value="java"/>
 		</attributes>
 	</classpathentry>
 	<classpathentry kind="output" path="target/classes"/>
diff --git a/jpa-moxy/jpa-moxy.simple/.project b/jpa-moxy/jpa-moxy.simple/.project
index 2e45d43..d295585 100644
--- a/jpa-moxy/jpa-moxy.simple/.project
+++ b/jpa-moxy/jpa-moxy.simple/.project
@@ -6,6 +6,11 @@
 	</projects>
 	<buildSpec>
 		<buildCommand>
+			<name>org.eclipse.wst.common.project.facet.core.builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
 			<name>org.eclipse.jdt.core.javabuilder</name>
 			<arguments>
 			</arguments>
@@ -15,9 +20,15 @@
 			<arguments>
 			</arguments>
 		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.wst.validation.validationbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
 	</buildSpec>
 	<natures>
 		<nature>org.eclipse.jdt.core.javanature</nature>
 		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
 	</natures>
 </projectDescription>
diff --git a/jpa-moxy/jpa-moxy.simple/.settings/org.eclipse.jdt.core.prefs b/jpa-moxy/jpa-moxy.simple/.settings/org.eclipse.jdt.core.prefs
index ec4300d..443e085 100644
--- a/jpa-moxy/jpa-moxy.simple/.settings/org.eclipse.jdt.core.prefs
+++ b/jpa-moxy/jpa-moxy.simple/.settings/org.eclipse.jdt.core.prefs
@@ -1,5 +1,8 @@
 eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
 org.eclipse.jdt.core.compiler.compliance=1.7
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
 org.eclipse.jdt.core.compiler.source=1.7
diff --git a/jpa-moxy/jpa-moxy.simple/.settings/org.eclipse.jpt.core.prefs b/jpa-moxy/jpa-moxy.simple/.settings/org.eclipse.jpt.core.prefs
new file mode 100644
index 0000000..dca3902
--- /dev/null
+++ b/jpa-moxy/jpa-moxy.simple/.settings/org.eclipse.jpt.core.prefs
@@ -0,0 +1,3 @@
+eclipse.preferences.version=1
+org.eclipse.jpt.core.platform=eclipselink2_4
+org.eclipse.jpt.jpa.core.discoverAnnotatedClasses=false
diff --git a/jpa-moxy/jpa-moxy.simple/.settings/org.eclipse.wst.common.project.facet.core.prefs.xml b/jpa-moxy/jpa-moxy.simple/.settings/org.eclipse.wst.common.project.facet.core.prefs.xml
new file mode 100644
index 0000000..7961132
--- /dev/null
+++ b/jpa-moxy/jpa-moxy.simple/.settings/org.eclipse.wst.common.project.facet.core.prefs.xml
@@ -0,0 +1,7 @@
+<root>
+  <facet id="jpt.jpa">
+    <node name="libprov">
+      <attribute name="provider-id" value="jpa-no-op-library-provider"/>
+    </node>
+  </facet>
+</root>
diff --git a/jpa-moxy/jpa-moxy.simple/.settings/org.eclipse.wst.common.project.facet.core.xml b/jpa-moxy/jpa-moxy.simple/.settings/org.eclipse.wst.common.project.facet.core.xml
new file mode 100644
index 0000000..65ffcc2
--- /dev/null
+++ b/jpa-moxy/jpa-moxy.simple/.settings/org.eclipse.wst.common.project.facet.core.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<faceted-project>
+  <installed facet="java" version="1.7"/>
+  <installed facet="jpt.jpa" version="2.0"/>
+</faceted-project>
diff --git a/jpa-moxy/jpa-moxy.simple/Marshall-JSON.launch b/jpa-moxy/jpa-moxy.simple/Marshall-JSON.launch
new file mode 100644
index 0000000..33c47d0
--- /dev/null
+++ b/jpa-moxy/jpa-moxy.simple/Marshall-JSON.launch
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<launchConfiguration type="org.eclipse.jdt.launching.localJavaApplication">
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
+<listEntry value="/jpa-moxy.simple/src/main/java/eclipselink/example/jpamoxy/simple/Marshall.java"/>
+</listAttribute>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
+<listEntry value="1"/>
+</listAttribute>
+<stringAttribute key="org.eclipse.jdt.launching.CLASSPATH_PROVIDER" value="org.eclipse.m2e.launchconfig.classpathProvider"/>
+<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="eclipselink.example.jpamoxy.simple.Marshall"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="json"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="jpa-moxy.simple"/>
+<stringAttribute key="org.eclipse.jdt.launching.SOURCE_PATH_PROVIDER" value="org.eclipse.m2e.launchconfig.sourcepathProvider"/>
+</launchConfiguration>
diff --git a/jpa-moxy/jpa-moxy.simple/Marshall-XML.launch b/jpa-moxy/jpa-moxy.simple/Marshall-XML.launch
new file mode 100644
index 0000000..575becd
--- /dev/null
+++ b/jpa-moxy/jpa-moxy.simple/Marshall-XML.launch
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<launchConfiguration type="org.eclipse.jdt.launching.localJavaApplication">
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
+<listEntry value="/jpa-moxy.simple/src/main/java/eclipselink/example/jpamoxy/simple/Marshall.java"/>
+</listAttribute>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
+<listEntry value="1"/>
+</listAttribute>
+<stringAttribute key="org.eclipse.jdt.launching.CLASSPATH_PROVIDER" value="org.eclipse.m2e.launchconfig.classpathProvider"/>
+<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="eclipselink.example.jpamoxy.simple.Marshall"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="xml"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="jpa-moxy.simple"/>
+<stringAttribute key="org.eclipse.jdt.launching.SOURCE_PATH_PROVIDER" value="org.eclipse.m2e.launchconfig.sourcepathProvider"/>
+</launchConfiguration>
diff --git a/jpa-moxy/jpa-moxy.simple/Unmarshall-JSON.launch b/jpa-moxy/jpa-moxy.simple/Unmarshall-JSON.launch
new file mode 100644
index 0000000..ff75534
--- /dev/null
+++ b/jpa-moxy/jpa-moxy.simple/Unmarshall-JSON.launch
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<launchConfiguration type="org.eclipse.jdt.launching.localJavaApplication">
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
+<listEntry value="/jpa-moxy.simple/src/main/java/eclipselink/example/jpamoxy/simple/Unmarshall.java"/>
+</listAttribute>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
+<listEntry value="1"/>
+</listAttribute>
+<stringAttribute key="org.eclipse.jdt.launching.CLASSPATH_PROVIDER" value="org.eclipse.m2e.launchconfig.classpathProvider"/>
+<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="eclipselink.example.jpamoxy.simple.Unmarshall"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="json"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="jpa-moxy.simple"/>
+<stringAttribute key="org.eclipse.jdt.launching.SOURCE_PATH_PROVIDER" value="org.eclipse.m2e.launchconfig.sourcepathProvider"/>
+</launchConfiguration>
diff --git a/jpa-moxy/jpa-moxy.simple/Unmarshall-XML.launch b/jpa-moxy/jpa-moxy.simple/Unmarshall-XML.launch
new file mode 100644
index 0000000..6b6c084
--- /dev/null
+++ b/jpa-moxy/jpa-moxy.simple/Unmarshall-XML.launch
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<launchConfiguration type="org.eclipse.jdt.launching.localJavaApplication">
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
+<listEntry value="/jpa-moxy.simple/src/main/java/eclipselink/example/jpamoxy/simple/Unmarshall.java"/>
+</listAttribute>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
+<listEntry value="1"/>
+</listAttribute>
+<stringAttribute key="org.eclipse.jdt.launching.CLASSPATH_PROVIDER" value="org.eclipse.m2e.launchconfig.classpathProvider"/>
+<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="eclipselink.example.jpamoxy.simple.Unmarshall"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="xml"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="jpa-moxy.simple"/>
+<stringAttribute key="org.eclipse.jdt.launching.SOURCE_PATH_PROVIDER" value="org.eclipse.m2e.launchconfig.sourcepathProvider"/>
+</launchConfiguration>
diff --git a/jpa-moxy/jpa-moxy.simple/diagrams/jpa-moxy.simple.xml b/jpa-moxy/jpa-moxy.simple/diagrams/jpa-moxy.simple.xml
new file mode 100644
index 0000000..29b9cb2
--- /dev/null
+++ b/jpa-moxy/jpa-moxy.simple/diagrams/jpa-moxy.simple.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?><entities>
+	<entity>
+		<entity-name>eclipselink.example.jpamoxy.simple.model.Address</entity-name>
+		<entity-width>120</entity-width>
+		<entity-height>166</entity-height>
+		<entity-X-Coordinate>430</entity-X-Coordinate>
+		<entity-Y-Coordinate>308</entity-Y-Coordinate>
+		<primary-collapsed>false</primary-collapsed>
+		<relation-collapsed>false</relation-collapsed>
+		<basic-collapsed>false</basic-collapsed>
+	</entity>
+
+	<entity>
+		<entity-name>eclipselink.example.jpamoxy.simple.model.Customer</entity-name>
+		<entity-width>120</entity-width>
+		<entity-height>186</entity-height>
+		<entity-X-Coordinate>220</entity-X-Coordinate>
+		<entity-Y-Coordinate>69</entity-Y-Coordinate>
+		<primary-collapsed>false</primary-collapsed>
+		<relation-collapsed>false</relation-collapsed>
+		<basic-collapsed>false</basic-collapsed>
+	</entity>
+
+	<entity>
+		<entity-name>eclipselink.example.jpamoxy.simple.model.PhoneNumber</entity-name>
+		<entity-width>120</entity-width>
+		<entity-height>166</entity-height>
+		<entity-X-Coordinate>520</entity-X-Coordinate>
+		<entity-Y-Coordinate>54</entity-Y-Coordinate>
+		<primary-collapsed>false</primary-collapsed>
+		<relation-collapsed>false</relation-collapsed>
+		<basic-collapsed>false</basic-collapsed>
+	</entity>
+</entities>
\ No newline at end of file
diff --git a/jpa-moxy/jpa-moxy.simple/src/main/java/eclipselink/example/jpamoxy/simple/Marshall.java b/jpa-moxy/jpa-moxy.simple/src/main/java/eclipselink/example/jpamoxy/simple/Marshall.java
index 101d07d..4aed018 100755
--- a/jpa-moxy/jpa-moxy.simple/src/main/java/eclipselink/example/jpamoxy/simple/Marshall.java
+++ b/jpa-moxy/jpa-moxy.simple/src/main/java/eclipselink/example/jpamoxy/simple/Marshall.java
@@ -1,5 +1,6 @@
 package eclipselink.example.jpamoxy.simple;
 
+import java.awt.Desktop;
 import java.io.File;
 
 import javax.persistence.EntityManager;
@@ -37,7 +38,18 @@
         marshaller.setProperty("eclipselink.json.wrapper-as-array-name", true);
         File file = new File("target/customer." + mediaType);
 		marshaller.marshal(customer, file);
+		
+		launchSystemBrowser(file);
 
 	}
+	
+    public static void launchSystemBrowser(File file) {
+        try {
+            Desktop.getDesktop().browse(file.toURI());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
 
 }
diff --git a/jpa/polyglot/polyglot.client/src/main/java/example/PolyglotDemo.java b/jpa/polyglot/polyglot.client/src/main/java/example/PolyglotDemo.java
index d6bc4c0..d32111d 100644
--- a/jpa/polyglot/polyglot.client/src/main/java/example/PolyglotDemo.java
+++ b/jpa/polyglot/polyglot.client/src/main/java/example/PolyglotDemo.java
@@ -70,10 +70,13 @@
         
         em = emf.createEntityManager();
         Order queriedOrder = em.find(Order.class, orderId);
-        System.err.println(queriedOrder.getDescription());
+        System.out.println(queriedOrder.getDescription());
         for (OrderLine orderLine : queriedOrder.getOrderLines()) {
-			System.err.println("  " + orderLine.getProduct().getDescription());
+			System.out.println("  " + orderLine.getProduct().getDescription());
 		}
+        
+        System.out.flush();
+        
         em.close();
     }
 }
diff --git a/jpa/polyglot/polyglot.composite/.classpath b/jpa/polyglot/polyglot.composite/.classpath
index 5d012a0..6c4902d 100644
--- a/jpa/polyglot/polyglot.composite/.classpath
+++ b/jpa/polyglot/polyglot.composite/.classpath
@@ -5,14 +5,14 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7">
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7">
 		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="owner.project.facets" value="java"/>
 		</attributes>
 	</classpathentry>
 	<classpathentry kind="output" path="target/classes"/>
diff --git a/jpa/polyglot/polyglot.composite/.project b/jpa/polyglot/polyglot.composite/.project
index ad76521..e0dfaf8 100644
--- a/jpa/polyglot/polyglot.composite/.project
+++ b/jpa/polyglot/polyglot.composite/.project
@@ -6,6 +6,11 @@
 	</projects>
 	<buildSpec>
 		<buildCommand>
+			<name>org.eclipse.wst.common.project.facet.core.builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
 			<name>org.eclipse.jdt.core.javabuilder</name>
 			<arguments>
 			</arguments>
@@ -15,9 +20,15 @@
 			<arguments>
 			</arguments>
 		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.wst.validation.validationbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
 	</buildSpec>
 	<natures>
 		<nature>org.eclipse.jdt.core.javanature</nature>
 		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
 	</natures>
 </projectDescription>
diff --git a/jpa/polyglot/polyglot.composite/.settings/org.eclipse.jdt.core.prefs b/jpa/polyglot/polyglot.composite/.settings/org.eclipse.jdt.core.prefs
index ec4300d..443e085 100644
--- a/jpa/polyglot/polyglot.composite/.settings/org.eclipse.jdt.core.prefs
+++ b/jpa/polyglot/polyglot.composite/.settings/org.eclipse.jdt.core.prefs
@@ -1,5 +1,8 @@
 eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
 org.eclipse.jdt.core.compiler.compliance=1.7
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
 org.eclipse.jdt.core.compiler.source=1.7
diff --git a/jpa/polyglot/polyglot.composite/.settings/org.eclipse.jpt.core.prefs b/jpa/polyglot/polyglot.composite/.settings/org.eclipse.jpt.core.prefs
new file mode 100644
index 0000000..8ebbcb4
--- /dev/null
+++ b/jpa/polyglot/polyglot.composite/.settings/org.eclipse.jpt.core.prefs
@@ -0,0 +1,5 @@
+eclipse.preferences.version=1
+org.eclipse.jpt.core.platform=eclipselink2_4
+org.eclipse.jpt.jpa.core.discoverAnnotatedClasses=false
+problem.PERSISTENCE_UNIT_NONEXISTENT_JAR_FILE=warning
+workspace_preferences_overriden=true
diff --git a/jpa/polyglot/polyglot.composite/.settings/org.eclipse.wst.common.project.facet.core.prefs.xml b/jpa/polyglot/polyglot.composite/.settings/org.eclipse.wst.common.project.facet.core.prefs.xml
new file mode 100644
index 0000000..7961132
--- /dev/null
+++ b/jpa/polyglot/polyglot.composite/.settings/org.eclipse.wst.common.project.facet.core.prefs.xml
@@ -0,0 +1,7 @@
+<root>
+  <facet id="jpt.jpa">
+    <node name="libprov">
+      <attribute name="provider-id" value="jpa-no-op-library-provider"/>
+    </node>
+  </facet>
+</root>
diff --git a/jpa/polyglot/polyglot.composite/.settings/org.eclipse.wst.common.project.facet.core.xml b/jpa/polyglot/polyglot.composite/.settings/org.eclipse.wst.common.project.facet.core.xml
new file mode 100644
index 0000000..65ffcc2
--- /dev/null
+++ b/jpa/polyglot/polyglot.composite/.settings/org.eclipse.wst.common.project.facet.core.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<faceted-project>
+  <installed facet="java" version="1.7"/>
+  <installed facet="jpt.jpa" version="2.0"/>
+</faceted-project>
diff --git a/jpa/polyglot/polyglot.composite/src/main/resources/META-INF/persistence.xml b/jpa/polyglot/polyglot.composite/src/main/resources/META-INF/persistence.xml
index 37781f1..39b904b 100644
--- a/jpa/polyglot/polyglot.composite/src/main/resources/META-INF/persistence.xml
+++ b/jpa/polyglot/polyglot.composite/src/main/resources/META-INF/persistence.xml
@@ -1,7 +1,7 @@
 <persistence xmlns="http://java.sun.com/xml/ns/persistence"
 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence persistence_1_0.xsd"
-	version="1.0">
+	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence persistence_2_0.xsd"
+	version="2.0">
 	<persistence-unit name="composite-pu" transaction-type="RESOURCE_LOCAL">
 		<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
 		<jar-file>relational-pu.jar</jar-file>
@@ -14,6 +14,7 @@
 			<property name="eclipselink.logging.session" value="false" />
 			<property name="eclipselink.logging.exceptions" value="false" />
 			<property name="eclipselink.logging.connection" value="false" />
+			<property name="eclipselink.logging.level.metadata" value="WARNING"></property>
 		</properties>
 	</persistence-unit>
 </persistence>
\ No newline at end of file
diff --git a/jpa/polyglot/polyglot.nosql/.classpath b/jpa/polyglot/polyglot.nosql/.classpath
index fc321d6..517e18a 100644
--- a/jpa/polyglot/polyglot.nosql/.classpath
+++ b/jpa/polyglot/polyglot.nosql/.classpath
@@ -11,14 +11,14 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7">
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7">
 		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="owner.project.facets" value="java"/>
 		</attributes>
 	</classpathentry>
 	<classpathentry kind="output" path="target/classes"/>
diff --git a/jpa/polyglot/polyglot.nosql/.project b/jpa/polyglot/polyglot.nosql/.project
index 4fa5566..ae3f1cf 100644
--- a/jpa/polyglot/polyglot.nosql/.project
+++ b/jpa/polyglot/polyglot.nosql/.project
@@ -6,6 +6,11 @@
 	</projects>
 	<buildSpec>
 		<buildCommand>
+			<name>org.eclipse.wst.common.project.facet.core.builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
 			<name>org.eclipse.jdt.core.javabuilder</name>
 			<arguments>
 			</arguments>
@@ -15,9 +20,15 @@
 			<arguments>
 			</arguments>
 		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.wst.validation.validationbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
 	</buildSpec>
 	<natures>
 		<nature>org.eclipse.jdt.core.javanature</nature>
 		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
 	</natures>
 </projectDescription>
diff --git a/jpa/polyglot/polyglot.nosql/.settings/org.eclipse.jdt.core.prefs b/jpa/polyglot/polyglot.nosql/.settings/org.eclipse.jdt.core.prefs
index ec4300d..443e085 100644
--- a/jpa/polyglot/polyglot.nosql/.settings/org.eclipse.jdt.core.prefs
+++ b/jpa/polyglot/polyglot.nosql/.settings/org.eclipse.jdt.core.prefs
@@ -1,5 +1,8 @@
 eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
 org.eclipse.jdt.core.compiler.compliance=1.7
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
 org.eclipse.jdt.core.compiler.source=1.7
diff --git a/jpa/polyglot/polyglot.nosql/.settings/org.eclipse.jpt.core.prefs b/jpa/polyglot/polyglot.nosql/.settings/org.eclipse.jpt.core.prefs
new file mode 100644
index 0000000..8775509
--- /dev/null
+++ b/jpa/polyglot/polyglot.nosql/.settings/org.eclipse.jpt.core.prefs
@@ -0,0 +1,7 @@
+eclipse.preferences.version=1
+org.eclipse.jpt.core.platform=eclipselink2_4
+org.eclipse.jpt.jpa.core.discoverAnnotatedClasses=false
+problem.TARGET_ENTITY_IS_NOT_AN_ENTITY=warning
+problem.VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY=warning
+problem.VIRTUAL_ATTRIBUTE_TARGET_ENTITY_NOT_DEFINED=warning
+workspace_preferences_overriden=true
diff --git a/jpa/polyglot/polyglot.nosql/.settings/org.eclipse.wst.common.project.facet.core.prefs.xml b/jpa/polyglot/polyglot.nosql/.settings/org.eclipse.wst.common.project.facet.core.prefs.xml
new file mode 100644
index 0000000..7961132
--- /dev/null
+++ b/jpa/polyglot/polyglot.nosql/.settings/org.eclipse.wst.common.project.facet.core.prefs.xml
@@ -0,0 +1,7 @@
+<root>
+  <facet id="jpt.jpa">
+    <node name="libprov">
+      <attribute name="provider-id" value="jpa-no-op-library-provider"/>
+    </node>
+  </facet>
+</root>
diff --git a/jpa/polyglot/polyglot.nosql/.settings/org.eclipse.wst.common.project.facet.core.xml b/jpa/polyglot/polyglot.nosql/.settings/org.eclipse.wst.common.project.facet.core.xml
new file mode 100644
index 0000000..65ffcc2
--- /dev/null
+++ b/jpa/polyglot/polyglot.nosql/.settings/org.eclipse.wst.common.project.facet.core.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<faceted-project>
+  <installed facet="java" version="1.7"/>
+  <installed facet="jpt.jpa" version="2.0"/>
+</faceted-project>
diff --git a/jpa/polyglot/polyglot.nosql/diagrams/polyglot.nosql-pu.xml b/jpa/polyglot/polyglot.nosql/diagrams/polyglot.nosql-pu.xml
new file mode 100644
index 0000000..387242d
--- /dev/null
+++ b/jpa/polyglot/polyglot.nosql/diagrams/polyglot.nosql-pu.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?><entities>
+	<entity>
+		<entity-name>model.Customer</entity-name>
+		<entity-width>120</entity-width>
+		<entity-height>108</entity-height>
+		<entity-X-Coordinate>200</entity-X-Coordinate>
+		<entity-Y-Coordinate>160</entity-Y-Coordinate>
+		<primary-collapsed>false</primary-collapsed>
+		<relation-collapsed>false</relation-collapsed>
+		<basic-collapsed>false</basic-collapsed>
+	</entity>
+
+	<entity>
+		<entity-name>model.Order</entity-name>
+		<entity-width>120</entity-width>
+		<entity-height>266</entity-height>
+		<entity-X-Coordinate>563</entity-X-Coordinate>
+		<entity-Y-Coordinate>200</entity-Y-Coordinate>
+		<primary-collapsed>false</primary-collapsed>
+		<relation-collapsed>false</relation-collapsed>
+		<basic-collapsed>false</basic-collapsed>
+	</entity>
+</entities>
\ No newline at end of file
diff --git a/jpa/polyglot/polyglot.nosql/src/main/resources/META-INF/persistence.xml b/jpa/polyglot/polyglot.nosql/src/main/resources/META-INF/persistence.xml
index 73a4be9..60fa0fd 100644
--- a/jpa/polyglot/polyglot.nosql/src/main/resources/META-INF/persistence.xml
+++ b/jpa/polyglot/polyglot.nosql/src/main/resources/META-INF/persistence.xml
@@ -17,7 +17,9 @@
 				value="27017" />
 			<property name="eclipselink.nosql.property.mongo.host"
 				value="localhost" />
+			
 			<property name="eclipselink.nosql.property.mongo.db" value="polyglot" />
+			
 			<property name="eclipselink.logging.level" value="FINEST" />
 			<property name="eclipselink.logging.timestamp" value="false" />
 			<property name="eclipselink.logging.thread" value="false" />
diff --git a/jpa/polyglot/polyglot.relational/.classpath b/jpa/polyglot/polyglot.relational/.classpath
index fc321d6..517e18a 100644
--- a/jpa/polyglot/polyglot.relational/.classpath
+++ b/jpa/polyglot/polyglot.relational/.classpath
@@ -11,14 +11,14 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7">
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7">
 		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="owner.project.facets" value="java"/>
 		</attributes>
 	</classpathentry>
 	<classpathentry kind="output" path="target/classes"/>
diff --git a/jpa/polyglot/polyglot.relational/.project b/jpa/polyglot/polyglot.relational/.project
index 152c4c0..1ff68e9 100644
--- a/jpa/polyglot/polyglot.relational/.project
+++ b/jpa/polyglot/polyglot.relational/.project
@@ -6,6 +6,11 @@
 	</projects>
 	<buildSpec>
 		<buildCommand>
+			<name>org.eclipse.wst.common.project.facet.core.builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
 			<name>org.eclipse.jdt.core.javabuilder</name>
 			<arguments>
 			</arguments>
@@ -15,9 +20,15 @@
 			<arguments>
 			</arguments>
 		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.wst.validation.validationbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
 	</buildSpec>
 	<natures>
 		<nature>org.eclipse.jdt.core.javanature</nature>
 		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
 	</natures>
 </projectDescription>
diff --git a/jpa/polyglot/polyglot.relational/.settings/org.eclipse.jdt.core.prefs b/jpa/polyglot/polyglot.relational/.settings/org.eclipse.jdt.core.prefs
index ec4300d..443e085 100644
--- a/jpa/polyglot/polyglot.relational/.settings/org.eclipse.jdt.core.prefs
+++ b/jpa/polyglot/polyglot.relational/.settings/org.eclipse.jdt.core.prefs
@@ -1,5 +1,8 @@
 eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
 org.eclipse.jdt.core.compiler.compliance=1.7
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
 org.eclipse.jdt.core.compiler.source=1.7
diff --git a/jpa/polyglot/polyglot.relational/.settings/org.eclipse.jpt.core.prefs b/jpa/polyglot/polyglot.relational/.settings/org.eclipse.jpt.core.prefs
new file mode 100644
index 0000000..dca3902
--- /dev/null
+++ b/jpa/polyglot/polyglot.relational/.settings/org.eclipse.jpt.core.prefs
@@ -0,0 +1,3 @@
+eclipse.preferences.version=1
+org.eclipse.jpt.core.platform=eclipselink2_4
+org.eclipse.jpt.jpa.core.discoverAnnotatedClasses=false
diff --git a/jpa/polyglot/polyglot.relational/.settings/org.eclipse.wst.common.project.facet.core.prefs.xml b/jpa/polyglot/polyglot.relational/.settings/org.eclipse.wst.common.project.facet.core.prefs.xml
new file mode 100644
index 0000000..7961132
--- /dev/null
+++ b/jpa/polyglot/polyglot.relational/.settings/org.eclipse.wst.common.project.facet.core.prefs.xml
@@ -0,0 +1,7 @@
+<root>
+  <facet id="jpt.jpa">
+    <node name="libprov">
+      <attribute name="provider-id" value="jpa-no-op-library-provider"/>
+    </node>
+  </facet>
+</root>
diff --git a/jpa/polyglot/polyglot.relational/.settings/org.eclipse.wst.common.project.facet.core.xml b/jpa/polyglot/polyglot.relational/.settings/org.eclipse.wst.common.project.facet.core.xml
new file mode 100644
index 0000000..65ffcc2
--- /dev/null
+++ b/jpa/polyglot/polyglot.relational/.settings/org.eclipse.wst.common.project.facet.core.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<faceted-project>
+  <installed facet="java" version="1.7"/>
+  <installed facet="jpt.jpa" version="2.0"/>
+</faceted-project>
diff --git a/jpa/polyglot/polyglot.relational/diagrams/polyglot.relational-pu.xml b/jpa/polyglot/polyglot.relational/diagrams/polyglot.relational-pu.xml
new file mode 100644
index 0000000..541d426
--- /dev/null
+++ b/jpa/polyglot/polyglot.relational/diagrams/polyglot.relational-pu.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?><entities>
+	<entity>
+		<entity-name>relational.model.Discount</entity-name>
+		<entity-width>120</entity-width>
+		<entity-height>108</entity-height>
+		<entity-X-Coordinate>490</entity-X-Coordinate>
+		<entity-Y-Coordinate>260</entity-Y-Coordinate>
+		<primary-collapsed>false</primary-collapsed>
+		<relation-collapsed>false</relation-collapsed>
+		<basic-collapsed>false</basic-collapsed>
+	</entity>
+
+	<entity>
+		<entity-name>relational.model.Product</entity-name>
+		<entity-width>120</entity-width>
+		<entity-height>108</entity-height>
+		<entity-X-Coordinate>270</entity-X-Coordinate>
+		<entity-Y-Coordinate>180</entity-Y-Coordinate>
+		<primary-collapsed>false</primary-collapsed>
+		<relation-collapsed>false</relation-collapsed>
+		<basic-collapsed>false</basic-collapsed>
+	</entity>
+</entities>
\ No newline at end of file
