<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">
    <persistence-unit name="nosql" transaction-type="RESOURCE_LOCAL">
        <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
        <class>org.eclipse.persistence.testing.models.jpa.nosql.Order</class>
        <class>org.eclipse.persistence.testing.models.jpa.nosql.Customer</class>
        <class>org.eclipse.persistence.testing.models.jpa.nosql.LineItem</class>
        <class>org.eclipse.persistence.testing.models.jpa.nosql.Address</class>
        <properties>
            <property name="eclipselink.target-database" value="org.eclipse.persistence.nosql.adapters.nosql.OracleNoSQLPlatform"/>
            <property name="eclipselink.nosql.connection-spec" value="org.eclipse.persistence.nosql.adapters.nosql.OracleNoSQLConnectionSpec"/>
            <property name="eclipselink.nosql.property.nosql.host" value="localhost:5000"/>
            <property name="eclipselink.nosql.property.nosql.store" value="kvstore"/>
            <!--property name="eclipselink.logging.level" value="FINEST"/-->
        </properties>
    </persistence-unit>
    <persistence-unit name="nosql-mapped" transaction-type="RESOURCE_LOCAL">
        <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
        <class>org.eclipse.persistence.testing.models.jpa.nosql.mapped.Order</class>
        <class>org.eclipse.persistence.testing.models.jpa.nosql.mapped.Customer</class>
        <class>org.eclipse.persistence.testing.models.jpa.nosql.mapped.Address</class>
        <properties>
            <property name="eclipselink.target-database" value="org.eclipse.persistence.nosql.adapters.nosql.OracleNoSQLPlatform"/>
            <property name="eclipselink.nosql.connection-spec" value="org.eclipse.persistence.nosql.adapters.nosql.OracleNoSQLConnectionSpec"/>
            <property name="eclipselink.nosql.property.nosql.host" value="localhost:5000,localhost:5000"/>
            <property name="eclipselink.nosql.property.nosql.store" value="kvstore"/>
            <!--property name="eclipselink.logging.level" value="FINEST"/-->
        </properties>
    </persistence-unit>
</persistence>
