<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"
	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 http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="example">
		<jta-data-source>test</jta-data-source>
		<mapping-file>META-INF/orm.xml</mapping-file>
		<class>temporal.EditionSetEntry</class>
		<class>temporal.EditionSet</class>
		<class>model.PersonHobby</class>
		<class>model.Hobby</class>
		<properties>
			<!-- Logging Config -->
			<property name="eclipselink.logging.level" value="FINE" />
			<property name="eclipselink.logging.timestamp" value="false" />
			<property name="eclipselink.logging.thread" value="false" />
			<property name="eclipselink.logging.session" value="false" />
			<property name="eclipselink.logging.connection" value="false" />
			<property name="eclipselink.logging.exceptions" value="false" />
			<property name="eclipselink.logging.level.ejb_or_metadata"
				value="WARNING" />

			<!-- Use a customizer to configure temporal type's descriptors -->
			<property name="eclipselink.session.customizer"
				value="temporal.persistence.ConfigureTemporalDescriptors" />
			<property name="eclipselink.logging.logger" value="DefaultLogger"/>
		</properties>
	</persistence-unit>
</persistence>
