Examples with CompoundHolder org.jpox.samples.compoundidentity.CompoundHolder used on opensource projects

Example 1 with CompoundHolder

use of org.jpox.samples.compoundidentity.CompoundHolder in project tests by datanucleus.

the class CompoundIdentityTest method testOneToManyBiFKDoubleDetachAttach.

/**
 * Test of detach-attach of 1-N bi FK relation with double compound identity.
 */
public void testOneToManyBiFKDoubleDetachAttach() {
    try {
        PersistenceManager pm = pmf.getPersistenceManager();
        Transaction tx = pm.currentTransaction();
        Object id = null;
        Object[] elements = new Object[6];
        try {
            tx.begin();
            CompoundHolder holder = new CompoundHolder("First Holder");
            CompoundRelated related = new CompoundRelated("First Related");
            elements[0] = new CompoundDoubleTarget(holder, related, 1.0);
            elements[1] = new CompoundDoubleTarget(holder, related, 2.0);
            elements[2] = new CompoundDoubleTarget(holder, related, 3.0);
            elements[3] = new CompoundDoubleTarget(holder, related, 4.0);
            elements[4] = new CompoundDoubleTarget(holder, related, 5.0);
            elements[5] = new CompoundDoubleTarget(holder, related, 6.0);
            holder.getList3().add(elements[0]);
            holder.getList3().add(elements[1]);
            holder.getList3().add(elements[2]);
            holder.getList3().add(elements[3]);
            pm.makePersistent(holder);
            tx.commit();
            id = pm.getObjectId(holder);
            // Detach the holder
            tx.begin();
            pm.getFetchPlan().addGroup("detach");
            CompoundHolder holder2 = (CompoundHolder) pm.detachCopy(pm.getObjectById(id, true));
            tx.commit();
            // Add more elements
            holder2.getList3().add(elements[4]);
            // Attach
            tx.begin();
            pm.makePersistent(holder2);
            tx.commit();
            // Check the results
            tx.begin();
            CompoundHolder holder3 = (CompoundHolder) pm.getObjectById(id, true);
            assertEquals(5, holder3.getList3().size());
            assertEquals(elements[0], holder3.getList3().get(0));
            assertEquals(elements[1], holder3.getList3().get(1));
            assertEquals(elements[2], holder3.getList3().get(2));
            assertEquals(elements[3], holder3.getList3().get(3));
            assertEquals(elements[4], holder3.getList3().get(4));
            tx.commit();
            // Go back and update the detached, adding the other element
            holder2.getList3().add(elements[5]);
            // Attach it
            tx.begin();
            pm.makePersistent(holder2);
            tx.commit();
            // Check the results
            tx.begin();
            holder3 = (CompoundHolder) pm.getObjectById(id, true);
            assertEquals(6, holder3.getList3().size());
            assertEquals(elements[0], holder3.getList3().get(0));
            assertEquals(elements[1], holder3.getList3().get(1));
            assertEquals(elements[2], holder3.getList3().get(2));
            assertEquals(elements[3], holder3.getList3().get(3));
            assertEquals(elements[4], holder3.getList3().get(4));
            assertEquals(elements[5], holder3.getList3().get(5));
            tx.commit();
        } catch (Exception e) {
            LOG.error(e);
            e.printStackTrace();
            fail(e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            try {
                tx.begin();
                CompoundHolder holder1 = (CompoundHolder) pm.getObjectById(id, true);
                holder1.getList3().clear();
                tx.commit();
            } finally {
                if (tx.isActive()) {
                    tx.rollback();
                }
                pm.close();
            }
        }
    } finally {
        clean(CompoundHolder.class);
        clean(CompoundDoubleTarget.class);
        clean(CompoundRelated.class);
    }
}

Example 2 with CompoundHolder

use of org.jpox.samples.compoundidentity.CompoundHolder in project tests by datanucleus.

the class CompoundIdentityTest method testOneToManyMapBiValueInKey.

/**
 * Test of compound identity 1-N relations with a map using ForeignKey and the map value stored in the key.
 */
public void testOneToManyMapBiValueInKey() {
    try {
        PersistenceManager pm = pmf.getPersistenceManager();
        Transaction tx = pm.currentTransaction();
        Object id = null;
        CompoundMapTarget2[] values = new CompoundMapTarget2[6];
        try {
            tx.begin();
            CompoundHolder holder1 = new CompoundHolder("First Holder");
            values[0] = new CompoundMapTarget2("First", holder1, 1.0);
            values[1] = new CompoundMapTarget2("Second", holder1, 2.0);
            values[2] = new CompoundMapTarget2("Third", holder1, 3.0);
            values[3] = new CompoundMapTarget2("Fourth", holder1, 4.0);
            values[4] = new CompoundMapTarget2("Fifth", holder1, 5.0);
            values[5] = new CompoundMapTarget2("Sixth", holder1, 6.0);
            for (int i = 0; i < 6; i++) {
                holder1.getMap2().put(values[i], values[i].getValue());
            }
            pm.makePersistent(holder1);
            tx.commit();
            id = pm.getObjectId(holder1);
            tx.begin();
            CompoundHolder holder2 = (CompoundHolder) pm.getObjectById(id, true);
            assertEquals(6, holder2.getMap2().size());
            assertEquals(new Double(1.0), holder2.getMap2().get(values[0]));
            assertEquals(new Double(2.0), holder2.getMap2().get(values[1]));
            assertEquals(new Double(3.0), holder2.getMap2().get(values[2]));
            assertEquals(new Double(4.0), holder2.getMap2().get(values[3]));
            assertEquals(new Double(5.0), holder2.getMap2().get(values[4]));
            assertEquals(new Double(6.0), holder2.getMap2().get(values[5]));
            tx.commit();
        } catch (Exception e) {
            LOG.error(e);
            e.printStackTrace();
            fail(e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
    } finally {
        clean(CompoundHolder.class);
        clean(CompoundMapTarget2.class);
    }
}

Example 3 with CompoundHolder

use of org.jpox.samples.compoundidentity.CompoundHolder in project tests by datanucleus.

the class CompoundIdentityTest method testOneToManyUniJoinTableDetachAttach.

/**
 * Test for detach-attach of 1-N uni join table compound relations.
 */
public void testOneToManyUniJoinTableDetachAttach() {
    try {
        PersistenceManager pm = pmf.getPersistenceManager();
        Transaction tx = pm.currentTransaction();
        Object id = null;
        Object[] elements_single = new Object[6];
        Object[] elements_double = new Object[6];
        try {
            tx.begin();
            CompoundHolder holder1 = new CompoundHolder("First Holder");
            CompoundRelated related1 = new CompoundRelated("First Related");
            elements_single[0] = new CompoundSingleTarget(holder1, 1.0);
            elements_single[1] = new CompoundSingleTarget(holder1, 2.0);
            elements_single[2] = new CompoundSingleTarget(holder1, 3.0);
            elements_single[3] = new CompoundSingleTarget(holder1, 4.0);
            holder1.getList1().add(elements_single[0]);
            holder1.getList1().add(elements_single[1]);
            holder1.getList1().add(elements_single[2]);
            holder1.getList1().add(elements_single[3]);
            elements_double[0] = new CompoundDoubleTarget(holder1, related1, 1.0);
            elements_double[1] = new CompoundDoubleTarget(holder1, related1, 2.0);
            elements_double[2] = new CompoundDoubleTarget(holder1, related1, 3.0);
            elements_double[3] = new CompoundDoubleTarget(holder1, related1, 4.0);
            holder1.getList2().add(elements_double[0]);
            holder1.getList2().add(elements_double[1]);
            holder1.getList2().add(elements_double[2]);
            holder1.getList2().add(elements_double[3]);
            pm.makePersistent(holder1);
            tx.commit();
            id = pm.getObjectId(holder1);
            // Detach the holder and elements
            tx.begin();
            pm.getFetchPlan().addGroup("detach");
            CompoundHolder holder2 = (CompoundHolder) pm.detachCopy(pm.getObjectById(id, true));
            tx.commit();
            // Add some more elements (single, double) to the holder
            elements_single[4] = new CompoundSingleTarget(holder1, 5.0);
            elements_single[5] = new CompoundSingleTarget(holder1, 6.0);
            holder2.getList1().add(elements_single[4]);
            holder2.getList1().add(elements_single[5]);
            elements_double[4] = new CompoundDoubleTarget(holder1, related1, 5.0);
            elements_double[5] = new CompoundDoubleTarget(holder1, related1, 6.0);
            holder2.getList2().add(elements_double[4]);
            holder2.getList2().add(elements_double[5]);
            // Attach the holder and elements
            tx.begin();
            pm.makePersistent(holder2);
            tx.commit();
            // Check the results
            tx.begin();
            CompoundHolder holder3 = (CompoundHolder) pm.getObjectById(id, true);
            assertEquals(6, holder3.getList1().size());
            assertEquals(elements_single[0], holder3.getList1().get(0));
            assertEquals(elements_single[1], holder3.getList1().get(1));
            assertEquals(elements_single[2], holder3.getList1().get(2));
            assertEquals(elements_single[3], holder3.getList1().get(3));
            assertEquals(elements_single[4], holder3.getList1().get(4));
            assertEquals(elements_single[5], holder3.getList1().get(5));
            assertEquals(6, holder3.getList2().size());
            assertEquals(elements_double[0], holder3.getList2().get(0));
            assertEquals(elements_double[1], holder3.getList2().get(1));
            assertEquals(elements_double[2], holder3.getList2().get(2));
            assertEquals(elements_double[3], holder3.getList2().get(3));
            assertEquals(elements_double[4], holder3.getList2().get(4));
            assertEquals(elements_double[5], holder3.getList2().get(5));
            tx.commit();
        } catch (Exception e) {
            LOG.error(e);
            e.printStackTrace();
            fail(e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
    } finally {
        PersistenceManager pm = pmf.getPersistenceManager();
        Transaction tx = pm.currentTransaction();
        try {
            tx.begin();
            Extent ex = pm.getExtent(CompoundHolder.class);
            Iterator iter = ex.iterator();
            while (iter.hasNext()) {
                CompoundHolder holder = (CompoundHolder) iter.next();
                holder.getList1().clear();
                holder.getList2().clear();
            }
            tx.commit();
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        clean(CompoundHolder.class);
        clean(CompoundSingleTarget.class);
        clean(CompoundDoubleTarget.class);
        clean(CompoundRelated.class);
    }
}

Example 4 with CompoundHolder

use of org.jpox.samples.compoundidentity.CompoundHolder in project tests by datanucleus.

the class CompoundIdentityTest method testOneToOneUniDouble.

/**
 * Basic test for persistence/retrieval using 1-1 uni relation with 2 source objects in target PK.
 */
public void testOneToOneUniDouble() {
    try {
        Object idHolder1 = null;
        Object idHolder2 = null;
        Object idHolder3 = null;
        Object[] idTargets = new Object[6];
        CompoundDoubleTarget[] targets = new CompoundDoubleTarget[6];
        PersistenceManager pm = pmf.getPersistenceManager();
        Transaction tx = pm.currentTransaction();
        try {
            tx.begin();
            CompoundHolder holder1 = new CompoundHolder("First Holder");
            CompoundHolder holder2 = new CompoundHolder("Second Holder");
            CompoundHolder holder3 = new CompoundHolder("Third Holder");
            CompoundRelated related1 = new CompoundRelated("First Related");
            CompoundRelated related2 = new CompoundRelated("Second Related");
            CompoundRelated related3 = new CompoundRelated("Third Related");
            targets[0] = new CompoundDoubleTarget(holder3, related2, 1.0);
            targets[1] = new CompoundDoubleTarget(holder3, related1, 2.0);
            targets[2] = new CompoundDoubleTarget(holder2, related3, 3.0);
            targets[3] = new CompoundDoubleTarget(holder2, related1, 4.0);
            targets[4] = new CompoundDoubleTarget(holder1, related3, 5.0);
            targets[5] = new CompoundDoubleTarget(holder1, related2, 6.0);
            pm.makePersistentAll(targets);
            tx.commit();
            idHolder1 = pm.getObjectId(holder1);
            idHolder2 = pm.getObjectId(holder2);
            idHolder3 = pm.getObjectId(holder3);
            for (int i = 0; i < targets.length; i++) {
                idTargets[i] = pm.getObjectId(targets[i]);
            }
        } catch (Exception e) {
            LOG.error(e);
            e.printStackTrace();
            fail(e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        pm = pmf.getPersistenceManager();
        tx = pm.currentTransaction();
        try {
            tx.begin();
            CompoundHolder holder1 = (CompoundHolder) pm.getObjectById(idHolder1, true);
            CompoundHolder holder2 = (CompoundHolder) pm.getObjectById(idHolder2, true);
            CompoundHolder holder3 = (CompoundHolder) pm.getObjectById(idHolder3, true);
            assertEquals("Name of holder is incorrect", "First Holder", holder1.getName());
            assertEquals("Name of holder is incorrect", "Second Holder", holder2.getName());
            assertEquals("Name of holder is incorrect", "Third Holder", holder3.getName());
            for (int i = 0; i < targets.length; i++) {
                CompoundDoubleTarget target = (CompoundDoubleTarget) pm.getObjectById(idTargets[i], false);
                assertEquals(i + 1, target.getValue(), 0);
                if (i == 0) {
                    assertEquals("Name of holder is incorrect", "Third Holder", target.getHolder().getName());
                    assertEquals("Name of related is incorrect", "Second Related", target.getRelated().getName());
                } else if (i == 1) {
                    assertEquals("Name of holder is incorrect", "Third Holder", target.getHolder().getName());
                    assertEquals("Name of related is incorrect", "First Related", target.getRelated().getName());
                } else if (i == 2) {
                    assertEquals("Name of holder is incorrect", "Second Holder", target.getHolder().getName());
                    assertEquals("Name of related is incorrect", "Third Related", target.getRelated().getName());
                } else if (i == 3) {
                    assertEquals("Name of holder is incorrect", "Second Holder", target.getHolder().getName());
                    assertEquals("Name of related is incorrect", "First Related", target.getRelated().getName());
                } else if (i == 4) {
                    assertEquals("Name of holder is incorrect", "First Holder", target.getHolder().getName());
                    assertEquals("Name of related is incorrect", "Third Related", target.getRelated().getName());
                } else if (i == 5) {
                    assertEquals("Name of holder is incorrect", "First Holder", target.getHolder().getName());
                    assertEquals("Name of related is incorrect", "Second Related", target.getRelated().getName());
                }
            }
            tx.commit();
        } catch (Exception e) {
            LOG.error(e);
            e.printStackTrace();
            fail(e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
    } finally {
        clean(CompoundDoubleTarget.class);
        clean(CompoundRelated.class);
        clean(CompoundHolder.class);
    }
}

Example 5 with CompoundHolder

use of org.jpox.samples.compoundidentity.CompoundHolder in project tests by datanucleus.

the class CompoundIdentityTest method testOneToManyUniJoinTableSingle.

/**
 * Test of compound identity 1-N relations using join table with single compound elements.
 */
public void testOneToManyUniJoinTableSingle() {
    try {
        PersistenceManager pm = pmf.getPersistenceManager();
        Transaction tx = pm.currentTransaction();
        Object id = null;
        CompoundSingleTarget[] elements = new CompoundSingleTarget[6];
        try {
            tx.begin();
            CompoundHolder holder1 = new CompoundHolder("First Holder");
            elements[0] = new CompoundSingleTarget(holder1, 1.0);
            elements[1] = new CompoundSingleTarget(holder1, 2.0);
            elements[2] = new CompoundSingleTarget(holder1, 3.0);
            elements[3] = new CompoundSingleTarget(holder1, 4.0);
            elements[4] = new CompoundSingleTarget(holder1, 5.0);
            elements[5] = new CompoundSingleTarget(holder1, 6.0);
            holder1.getList1().add(elements[0]);
            holder1.getList1().add(elements[1]);
            holder1.getList1().add(elements[2]);
            holder1.getList1().add(elements[3]);
            holder1.getList1().add(elements[4]);
            holder1.getList1().add(elements[5]);
            pm.makePersistent(holder1);
            tx.commit();
            id = pm.getObjectId(holder1);
            tx.begin();
            CompoundHolder holder2 = (CompoundHolder) pm.getObjectById(id, true);
            assertEquals(6, holder2.getList1().size());
            assertEquals(elements[0], holder2.getList1().get(0));
            assertEquals(elements[1], holder2.getList1().get(1));
            assertEquals(elements[2], holder2.getList1().get(2));
            assertEquals(elements[3], holder2.getList1().get(3));
            assertEquals(elements[4], holder2.getList1().get(4));
            assertEquals(elements[5], holder2.getList1().get(5));
            tx.commit();
        } catch (Exception e) {
            LOG.error(e);
            e.printStackTrace();
            fail(e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
    } finally {
        clean(CompoundHolder.class);
        clean(CompoundSingleTarget.class);
    }
}