jpa-performance/src/example/Test.java

/*******************************************************************************
 * Copyright (c) 1998, 2012 Oracle and/or its affiliates. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *      Oracle - initial impl
 ******************************************************************************/
package example;

import java.math.BigDecimal;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

import model.*;

/**
 * Simulates a migration of 100,000 objects from MySQL to Oracle.
 * @author James Sutherland
 */
public class Test {
    
    public static int CUSTOMERS = 1000;
    public static int ORDERS = 10;
    public static int ORDERLINES = 10;

    public static void main(String[] args) throws Exception {
        try {
            Test test = new Test();
            test.setupDatabase();
            test.migrateDatabase();
            test.verifyMigration();
        } catch (Exception error) {
            error.printStackTrace();
        }
    }
    
    /**
     * Setup the original database that is to be migrated (normally this would be an existing database).
     * This is not part of the test.
     */
    public void setupDatabase() {
        System.out.println("Setting up database.");
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("order-old");
        EntityManager em = emf.createEntityManager();
        // Check if database exists.
        boolean recreate = false;
        long count = (Long)em.createQuery("Select count(c) from Customer c").getSingleResult();
        long count2 = (Long)em.createQuery("Select count(o) from Order o").getSingleResult();
        if ((count != CUSTOMERS) || (count2 != (ORDERS * CUSTOMERS))) {
            recreate = true;
            em.getTransaction().begin();
            em.createQuery("Delete from OrderLine ol").executeUpdate();
            em.createQuery("Delete from Order o").executeUpdate();
            em.createQuery("Delete from Customer c").executeUpdate();
            em.getTransaction().commit();
        }
        if (recreate) {
            // Create 100 customers with 100 orders with 10 order lines ~= 100,000 objects.
            for (int index = 0; index < CUSTOMERS; index++) {
                em.getTransaction().begin();
                Customer customer = new Customer();
                customer.setName("Cust#" + index);
                for (int index2 = 0; index2 < ORDERS; index2++) {
                    Order order = new Order();
                    order.setDescription("Order#" + (index * ORDERS + index2));
                    order.setCustomer(customer);
                    for (int index3 = 0; index3 < ORDERLINES; index3++) {
                        OrderLine orderLine = new OrderLine();
                        orderLine.setDescription("OrderLine#" + ((index * ORDERS) + (index2 * ORDERLINES) + index3));
                        orderLine.setLineNumber(index3);
                        orderLine.setCost(new BigDecimal(index3 * 100 + index2 + 5.99));
                        order.addOrderLine(orderLine);
                    }
                    em.persist(order);
                }
                em.getTransaction().commit();
                em.clear();
            }
        }
        emf.close();
        emf = Persistence.createEntityManagerFactory("order");
        em = emf.createEntityManager();
        // Clear any data from new database from previous runs.
        em.getTransaction().begin();
        em.createQuery("Delete from OrderLine ol").executeUpdate();
        em.createQuery("Delete from Order o").executeUpdate();
        em.createQuery("Delete from Customer c").executeUpdate();
        em.getTransaction().commit();
        em.close();
        emf.close();
        System.out.println("Setup complete.");
    }
        
    public void migrateDatabase() {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("order");
        EntityManager em = emf.createEntityManager();
        EntityManagerFactory emfOld = Persistence.createEntityManagerFactory("order-old");
        EntityManager emOld = emfOld.createEntityManager();
        System.out.println("Migrating database.");
        long start = System.currentTimeMillis();
        Query query = emOld.createQuery("Select o from Order o");
        List<Order> orders = query.getResultList();
        em.getTransaction().begin();
        // Reset old Ids, so they are assigned from the new database.
        for (Order order : orders) {
            order.setId(0);
            order.getCustomer().setId(0);
        }
        for (Order order : orders) {
            em.persist(order);
            for (OrderLine orderLine : order.getOrderLines()) {
                em.persist(orderLine);
            }
        }
        em.getTransaction().commit();
        em.close();
        emOld.close();
        System.out.println("Migration complete.");
        long end = System.currentTimeMillis();
        System.out.println("Total time:" + (end - start));
        emf.close();     
        emfOld.close();
    }
    
    /**
     * Verify the correct number of objects were migrated.
     */
    public void verifyMigration() {
        System.out.println("Verifying migration.");
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("order");
        EntityManager em = emf.createEntityManager();
        long count = (Long)em.createQuery("Select count(c) from Customer c").getSingleResult();
        if (count == CUSTOMERS) {
            System.out.println("Migrated " + count + " customers.");
        } else {
            System.out.println("Migration failed, expected " + CUSTOMERS + " customers, migrated " + count);
        }
        long count2 = (Long)em.createQuery("Select count(o) from Order o").getSingleResult();
        if (count2 == (CUSTOMERS * ORDERS)) {
            System.out.println("Migrated " + count2 + " orders.");
        } else {
            System.out.println("Migration failed, expected " + (CUSTOMERS * ORDERS) + " orders, migrated " + count2);
        }
        long count3 = (Long)em.createQuery("Select count(ol) from OrderLine ol").getSingleResult();
        if (count3 == (CUSTOMERS * ORDERS * ORDERLINES)) {
            System.out.println("Migrated " + count3 + " order lines.");
        } else {
            System.out.println("Migration failed, expected " + (CUSTOMERS * ORDERS * ORDERLINES) + " order lines, migrated " + count3);
        }
    }
}