Examples of org.caffinitas.mapper.core.PersistenceSession

org.caffinitas.mapper.core.PersistenceSession
Represents a session to access data in Cassandra.
Note: unlike relational databases Cassandra does not (really) distinguish between {@code INSERT} and {@code UPDATE}. It is perfectly legal to {@code INSERT} the same primary key twice - this results in an update.Similar for {@code UPDATE} - an {@code UPDATE} to a non-existing primary key results in an persist.This is called an {@code UPSERT}.

            SimpleEntity.class));
    }


    @Test(dependsOnMethods = "createSchema")
    public void tablePerClass_root_sameCondition() throws Exception {
        PersistenceSession session = persistenceManager.createSession();
        try {
            QueryBinder<TpcBaseEntity> queryBinder = session.createQueryBinder(TpcBaseEntity.class, null, "id in :id", null);
            queryBinder.setList("id", Arrays.asList(1, 2, 3));
            List<TpcBaseEntity> result = session.executeQuery(queryBinder);


            Assert.assertNotNull(result);
            Assert.assertTrue(result.isEmpty());


            // as named query


            queryBinder = session.createNamedQueryBinder(TpcBaseEntity.class, null, "byIds");
            queryBinder.setList("id", Arrays.asList(1, 2, 3));
            result = session.executeQuery(queryBinder);


            Assert.assertNotNull(result);
            Assert.assertTrue(result.isEmpty());


            // insert data


            TpcBaseEntity inst = new TpcBaseEntity();
            inst.setId(11);
            inst.setVal("one");
            session.insert(inst);
            inst.setId(12);
            inst.setVal("two");
            session.insert(inst);
            inst.setId(13);
            inst.setVal("three");
            session.insert(inst);


            // again


            queryBinder = session.createQueryBinder(TpcBaseEntity.class, null, "id in :id", null);
            queryBinder.setList("id", Arrays.asList(11, 12, 13));
            result = session.executeQuery(queryBinder);


            Assert.assertNotNull(result);
            Assert.assertEquals(result.size(), 3);


            // as named query


            queryBinder = session.createNamedQueryBinder(TpcBaseEntity.class, null, "byIds");
            queryBinder.setList("id", Arrays.asList(11, 12, 13));
            result = session.executeQuery(queryBinder);


            Assert.assertNotNull(result);
            Assert.assertEquals(result.size(), 3);
        } finally {session.close();}
    }

View Full Code Here

        createSchemaDo(Collections.<Class<?>>singletonList(CompEntity.class));
    }


    @Test(dependsOnMethods = "createSchema")
    public void composite_insertAndLoad() throws Exception {
        PersistenceSession session = persistenceManager.createSession();
        try {
            CompEntity inst = new CompEntity();
            inst.setId(11);
            CompComposite comp = new CompComposite();
            comp.setStr("string");
            comp.setNum(42);
            inst.setComp(comp);
            session.insert(inst);


            CompEntity loaded = session.loadOne(CompEntity.class, 11);
            Assert.assertNotNull(loaded);
            Assert.assertNotNull(loaded.getComp());
            Assert.assertEquals(loaded.getComp().getNum(), 42);
            Assert.assertEquals(loaded.getComp().getStr(), "string");
        } finally {session.close();}
    }

View Full Code Here

        } finally {session.close();}
    }


    @Test(dependsOnMethods = "createSchema")
    public void tablePerClass_root_differentConditions() throws Exception {
        PersistenceSession session = persistenceManager.createSession();
        try {
            Map<Class<? extends TpcBaseEntity>, String> conditionMap = new HashMap<Class<? extends TpcBaseEntity>, String>();
            conditionMap.put(TpcBaseEntity.class, "id = :id1");
            conditionMap.put(TpcInheritA.class, "id = :id2");
            conditionMap.put(TpcInheritB.class, "id = :id3");
            conditionMap.put(TpcInheritB2.class, "id = :id4");
            conditionMap.put(TpcInheritC.class, "id = :id5");
            QueryBinder<TpcBaseEntity> queryBinder = session.createQueryBinder(TpcBaseEntity.class, null, null, conditionMap);
            queryBinder.setInt("id1", 31);
            queryBinder.setInt("id2", 32);
            queryBinder.setInt("id3", 33);
            queryBinder.setInt("id4", 34);
            queryBinder.setInt("id5", 35);
            List<TpcBaseEntity> result = session.executeQuery(queryBinder);


            Assert.assertNotNull(result);
            Assert.assertTrue(result.isEmpty());


            // as named query


            queryBinder = session.createNamedQueryBinder(TpcBaseEntity.class, null, "byOther");
            queryBinder.setInt("id1", 31);
            queryBinder.setInt("id2", 32);
            queryBinder.setInt("id3", 33);
            queryBinder.setInt("id4", 34);
            queryBinder.setInt("id5", 35);
            result = session.executeQuery(queryBinder);


            Assert.assertNotNull(result);
            Assert.assertTrue(result.isEmpty());


            // insert data


            TpcBaseEntity inst = new TpcBaseEntity();
            inst.setId(31);
            inst.setVal("one");
            session.insert(inst);
            inst = new TpcInheritA();
            inst.setId(32);
            inst.setVal("two");
            session.insert(inst);
            inst = new TpcInheritB();
            inst.setId(33);
            inst.setVal("three");
            session.insert(inst);
            inst = new TpcInheritB2();
            inst.setId(34);
            inst.setVal("three");
            session.insert(inst);
            inst = new TpcInheritC();
            inst.setId(35);
            inst.setVal("three");
            session.insert(inst);


            // again


            queryBinder = session.createQueryBinder(TpcBaseEntity.class, null, null, conditionMap);
            queryBinder.setInt("id1", 31);
            queryBinder.setInt("id2", 32);
            queryBinder.setInt("id3", 33);
            queryBinder.setInt("id4", 34);
            queryBinder.setInt("id5", 35);
            result = session.executeQuery(queryBinder);


            Assert.assertNotNull(result);
            Assert.assertEquals(result.size(), 5);


            // as named query


            queryBinder = session.createNamedQueryBinder(TpcBaseEntity.class, null, "byOther");
            queryBinder.setInt("id1", 31);
            queryBinder.setInt("id2", 32);
            queryBinder.setInt("id3", 33);
            queryBinder.setInt("id4", 34);
            queryBinder.setInt("id5", 35);
            result = session.executeQuery(queryBinder);


            Assert.assertNotNull(result);
            Assert.assertEquals(result.size(), 5);
        } finally {session.close();}
    }

View Full Code Here

        } finally {session.close();}
    }


    @Test(dependsOnMethods = "tablePerClass_root_sameCondition")
    public void tablePerClass_atB_sameCondition() throws Exception {
        PersistenceSession session = persistenceManager.createSession();
        try {
            QueryBinder<TpcInheritB> queryBinder = session.createQueryBinder(TpcInheritB.class, null, "id in :id", null);
            queryBinder.setList("id", Arrays.asList(1, 2, 3));
            List<TpcInheritB> result = session.executeQuery(queryBinder);


            Assert.assertNotNull(result);
            Assert.assertTrue(result.isEmpty());


            // as named query


            queryBinder = session.createNamedQueryBinder(TpcInheritB.class, null, "byIds");
            queryBinder.setList("id", Arrays.asList(1, 2, 3));
            result = session.executeQuery(queryBinder);


            Assert.assertNotNull(result);
            Assert.assertTrue(result.isEmpty());


            // insert data


            TpcInheritB inst = new TpcInheritB();
            inst.setId(21);
            inst.setVal("one");
            session.insert(inst);
            inst.setId(22);
            inst.setVal("two");
            session.insert(inst);
            inst.setId(23);
            inst.setVal("three");
            session.insert(inst);


            // again


            queryBinder = session.createQueryBinder(TpcInheritB.class, null, "id in :id", null);
            queryBinder.setList("id", Arrays.asList(11, 12, 13, 21, 22, 23));
            result = session.executeQuery(queryBinder);


            Assert.assertNotNull(result);
            Assert.assertEquals(result.size(), 3);


            // as named query


            queryBinder = session.createNamedQueryBinder(TpcInheritB.class, null, "byIds");
            queryBinder.setList("id", Arrays.asList(11, 12, 13, 21, 22, 23));
            result = session.executeQuery(queryBinder);


            Assert.assertNotNull(result);
            Assert.assertEquals(result.size(), 3);
        } finally {session.close();}
    }

View Full Code Here

    }


    @Test(dependsOnMethods = "tracking_insertAndLoad")
    public void tracking_insertUpdateNoChange() throws Exception {


        PersistenceSession session = persistenceManager.createTrackingSession();
        try {
            TrackingEntity loaded = session.loadOne(TrackingEntity.class, 11);


            ModifyFuture<TrackingEntity> f = session.updateAsync(loaded);
            Assert.assertTrue(f.getClass().getName().toLowerCase().contains("immediate"));
        } finally {session.close();}
    }

View Full Code Here

    }


    @Test(dependsOnMethods = "createSchema")
    public void tracking_flushOnClose() throws Exception {


        PersistenceSession session = persistenceManager.createTrackingSession();
        try {
            TrackingEntity inst = new TrackingEntity();
            inst.setId(21);
            inst.setStr("str");
            inst.setValue("val");
            session.insert(inst);


            inst.setStr("modified");
        } finally {session.close();}


        session = persistenceManager.createTrackingSession();
        try {
            TrackingEntity loaded = session.loadOne(TrackingEntity.class, 21);
            Assert.assertEquals(loaded.getStr(), "modified");
        } finally {session.close();}
    }

View Full Code Here

        Assert.assertEquals(entityB2.getAllColumns().length, 8);
        Assert.assertEquals(entityC.getAllColumns().length, 8);


        waitEntityAvailable(entityBase);


        PersistenceSession session = persistenceManager.createSession();
        try {


            StBaseEntity instBase = new StBaseEntity();
            instBase.setId(1);
            instBase.setCid(1);
            instBase.setVal("val1");
            session.insert(instBase);


            StInheritA instA = new StInheritA();
            instA.setId(2);
            instA.setCid(1);
            instA.setVal("val2");
            instA.setInhA("inhA");
            session.insert(instA);


            StInheritB instB = new StInheritB();
            instB.setId(3);
            instB.setCid(1);
            instB.setVal("val3");
            instB.setInhB("inhB");
            session.insert(instB);


            StInheritB2 instB2 = new StInheritB2();
            instB2.setId(4);
            instB2.setCid(1);
            instB2.setVal("val4");
            instB2.setInhB("inhB");
            instB2.setInhB2("inhB2");
            session.insert(instB2);


            StInheritC instC = new StInheritC();
            instC.setId(5);
            instC.setCid(1);
            instC.setVal("val5");
            instC.setInhC("inhC");
            session.insert(instC);


            StBaseEntity loadedBase = session.loadOne(StBaseEntity.class, 1);
            Assert.assertNotNull(loadedBase);
            Assert.assertEquals(loadedBase.getId(), 1);
            Assert.assertEquals(loadedBase.getVal(), "val1");


            insertUpdateDelete(session, StBaseEntity.class, instBase, new UpdateCallback<StBaseEntity>() {
                @Override public void modify(StBaseEntity inst) {
                    //
                }


                @Override public void check(StBaseEntity inst) {
                    Assert.assertEquals(inst.getVal(), "val1");
                }
            }, 1);
            session.insert(loadedBase);


            StBaseEntity loadedA = session.loadOne(StBaseEntity.class, 2);
            Assert.assertNotNull(loadedA);
            Assert.assertEquals(loadedA.getId(), 2);
            Assert.assertEquals(loadedA.getVal(), "val2");
            Assert.assertTrue(loadedA instanceof StInheritA);
            Assert.assertEquals(((StInheritA) loadedA).getInhA(), "inhA");


            insertUpdateDelete(session, StBaseEntity.class, loadedA, new UpdateCallback<StBaseEntity>() {
                @Override public void modify(StBaseEntity inst) {
                    Assert.assertTrue(inst instanceof StInheritA);
                }


                @Override public void check(StBaseEntity inst) {
                    Assert.assertTrue(inst instanceof StInheritA);
                    Assert.assertEquals(inst.getVal(), "val2");
                }
            }, 2);
            session.insert(loadedA);


            StBaseEntity loadedB = session.loadOne(StBaseEntity.class, 3);
            Assert.assertNotNull(loadedB);
            Assert.assertEquals(loadedB.getId(), 3);
            Assert.assertEquals(loadedB.getVal(), "val3");
            Assert.assertTrue(loadedB instanceof StInheritB);
            Assert.assertEquals(((StInheritB) loadedB).getInhB(), "inhB");


            insertUpdateDelete(session, StBaseEntity.class, loadedB, new UpdateCallback<StBaseEntity>() {
                @Override public void modify(StBaseEntity inst) {
                    Assert.assertTrue(inst instanceof StInheritB);
                }


                @Override public void check(StBaseEntity inst) {
                    Assert.assertTrue(inst instanceof StInheritB);
                    Assert.assertEquals(inst.getVal(), "val3");
                }
            }, 3);
            session.insert(loadedB);


            StBaseEntity loadedB2 = session.loadOne(StBaseEntity.class, 4);
            Assert.assertNotNull(loadedB2);
            Assert.assertEquals(loadedB2.getId(), 4);
            Assert.assertEquals(loadedB2.getVal(), "val4");
            Assert.assertTrue(loadedB2 instanceof StInheritB2);
            Assert.assertEquals(((StInheritB) loadedB2).getInhB(), "inhB");
            Assert.assertEquals(((StInheritB2) loadedB2).getInhB2(), "inhB2");


            insertUpdateDelete(session, StBaseEntity.class, loadedB2, new UpdateCallback<StBaseEntity>() {
                @Override public void modify(StBaseEntity inst) {
                    Assert.assertTrue(inst instanceof StInheritB2);
                }


                @Override public void check(StBaseEntity inst) {
                    Assert.assertTrue(inst instanceof StInheritB2);
                    Assert.assertEquals(inst.getVal(), "val4");
                }
            }, 4);
            session.insert(loadedB2);


            StBaseEntity loadedC = session.loadOne(StBaseEntity.class, 5);
            Assert.assertNotNull(loadedC);
            Assert.assertEquals(loadedC.getId(), 5);
            Assert.assertEquals(loadedC.getVal(), "val5");
            Assert.assertTrue(loadedC instanceof StInheritC);
            Assert.assertEquals(((StInheritC) loadedC).getInhC(), "inhC");


            insertUpdateDelete(session, StBaseEntity.class, loadedC, new UpdateCallback<StBaseEntity>() {
                @Override public void modify(StBaseEntity inst) {
                    Assert.assertTrue(inst instanceof StInheritC);
                }


                @Override public void check(StBaseEntity inst) {
                    Assert.assertTrue(inst instanceof StInheritC);
                    Assert.assertEquals(inst.getVal(), "val5");
                }
            }, 5);
            session.insert(loadedC);


            loadedA = session.loadOne(StInheritA.class, 2);
            Assert.assertNotNull(loadedA);
            Assert.assertEquals(loadedA.getId(), 2);
            Assert.assertEquals(loadedA.getVal(), "val2");
            Assert.assertTrue(loadedA instanceof StInheritA);
            Assert.assertEquals(((StInheritA) loadedA).getInhA(), "inhA");


            insertUpdateDelete(session, StInheritA.class, (StInheritA) loadedA, new UpdateCallback<StInheritA>() {
                @Override public void modify(StInheritA inst) {
                    Assert.assertTrue(inst instanceof StInheritA);
                }


                @Override public void check(StInheritA inst) {
                    Assert.assertEquals(inst.getVal(), "val2");
                }
            }, 2);


            loadedB = session.loadOne(StBaseEntity.class, 3);
            Assert.assertNotNull(loadedB);
            Assert.assertEquals(loadedB.getId(), 3);
            Assert.assertEquals(loadedB.getVal(), "val3");
            Assert.assertTrue(loadedB instanceof StInheritB);
            Assert.assertEquals(((StInheritB) loadedB).getInhB(), "inhB");


            insertUpdateDelete(session, StBaseEntity.class, loadedB, new UpdateCallback<StBaseEntity>() {
                @Override public void modify(StBaseEntity inst) {
                    Assert.assertTrue(inst instanceof StInheritB);
                }


                @Override public void check(StBaseEntity inst) {
                    Assert.assertEquals(inst.getVal(), "val3");
                }
            }, 3);


            loadedB2 = session.loadOne(StInheritB.class, 4);
            Assert.assertNotNull(loadedB2);
            Assert.assertEquals(loadedB2.getId(), 4);
            Assert.assertEquals(loadedB2.getVal(), "val4");
            Assert.assertTrue(loadedB2 instanceof StInheritB2);
            Assert.assertEquals(((StInheritB) loadedB2).getInhB(), "inhB");
            Assert.assertEquals(((StInheritB2) loadedB2).getInhB2(), "inhB2");


            insertUpdateDelete(session, StInheritB.class, (StInheritB) loadedB2, new UpdateCallback<StInheritB>() {
                @Override public void modify(StInheritB inst) {
                    Assert.assertTrue(inst instanceof StInheritB2);
                }


                @Override public void check(StInheritB inst) {
                    Assert.assertEquals(inst.getVal(), "val4");
                }
            }, 4);
            session.insert(loadedB2);


            loadedB2 = session.loadOne(StInheritB2.class, 4);
            Assert.assertNotNull(loadedB2);
            Assert.assertEquals(loadedB2.getId(), 4);
            Assert.assertEquals(loadedB2.getVal(), "val4");
            Assert.assertTrue(loadedB2 instanceof StInheritB2);
            Assert.assertEquals(((StInheritB) loadedB2).getInhB(), "inhB");
            Assert.assertEquals(((StInheritB2) loadedB2).getInhB2(), "inhB2");


            insertUpdateDelete(session, StInheritB2.class, (StInheritB2) loadedB2, new UpdateCallback<StInheritB2>() {
                @Override public void modify(StInheritB2 inst) {
                    Assert.assertTrue(inst instanceof StInheritB2);
                }


                @Override public void check(StInheritB2 inst) {
                    Assert.assertEquals(inst.getVal(), "val4");
                }
            }, 4);


            loadedC = session.loadOne(StInheritC.class, 5);
            Assert.assertNotNull(loadedC);
            Assert.assertEquals(loadedC.getId(), 5);
            Assert.assertEquals(loadedC.getVal(), "val5");
            Assert.assertTrue(loadedC instanceof StInheritC);
            Assert.assertEquals(((StInheritC) loadedC).getInhC(), "inhC");


            insertUpdateDelete(session, StInheritC.class, (StInheritC) loadedC, new UpdateCallback<StInheritC>() {
                @Override public void modify(StInheritC inst) {
                    Assert.assertTrue(inst instanceof StInheritC);
                }


                @Override public void check(StInheritC inst) {
                    Assert.assertEquals(inst.getVal(), "val5");
                }
            }, 5);


            //
            //
            //


            instBase = new StBaseEntity();
            instBase.setId(1);
            instBase.setCid(1);
            instBase.setVal("val1");
            session.insert(instBase);


            instA = new StInheritA();
            instA.setId(1);
            instA.setCid(2);
            instA.setVal("val2");
            instA.setInhA("inhA");
            session.insert(instA);


            instB = new StInheritB();
            instB.setId(1);
            instB.setCid(3);
            instB.setVal("val3");
            instB.setInhB("inhB");
            session.insert(instB);


            instB2 = new StInheritB2();
            instB2.setId(1);
            instB2.setCid(4);
            instB2.setVal("val4");
            instB2.setInhB("inhB");
            instB2.setInhB2("inhB2");
            session.insert(instB2);


            instC = new StInheritC();
            instC.setId(1);
            instC.setCid(5);
            instC.setVal("val5");
            instC.setInhC("inhC");
            session.insert(instC);


            List<StBaseEntity> multiple = session.loadMultiple(StBaseEntity.class, 1);
            Assert.assertNotNull(multiple);
            Assert.assertEquals(multiple.size(), 5);


            List<StBaseEntity> none = session.loadMultiple(StBaseEntity.class, 0);
            Assert.assertNotNull(none);
            Assert.assertEquals(none.size(), 0);


        } finally {session.close();}
    }

View Full Code Here

        waitEntityAvailable(entityA);
        waitEntityAvailable(entityB);
        waitEntityAvailable(entityB2);
        waitEntityAvailable(entityC);


        PersistenceSession session = persistenceManager.createSession();
        try {


            TpcBaseEntity instBase = new TpcBaseEntity();
            instBase.setId(1);
            instBase.setCid(1);
            instBase.setVal("val1");
            session.insert(instBase);


            TpcInheritA instA = new TpcInheritA();
            instA.setId(2);
            instA.setCid(1);
            instA.setVal("val2");
            instA.setInhA("inhA");
            session.insert(instA);


            TpcInheritB instB = new TpcInheritB();
            instB.setId(3);
            instB.setCid(1);
            instB.setVal("val3");
            instB.setInhB("inhB");
            session.insert(instB);


            TpcInheritB2 instB2 = new TpcInheritB2();
            instB2.setId(4);
            instB2.setCid(1);
            instB2.setVal("val4");
            instB2.setInhB("inhB");
            instB2.setInhB2("inhB2");
            session.insert(instB2);


            TpcInheritC instC = new TpcInheritC();
            instC.setId(5);
            instC.setCid(1);
            instC.setVal("val5");
            instC.setInhC("inhC");
            session.insert(instC);


            TpcBaseEntity loadedBase = session.loadOne(TpcBaseEntity.class, 1);
            Assert.assertNotNull(loadedBase);
            Assert.assertEquals(loadedBase.getId(), 1);
            Assert.assertEquals(loadedBase.getVal(), "val1");


            TpcBaseEntity loadedA = session.loadOne(TpcInheritA.class, 2);
            Assert.assertNotNull(loadedA);
            Assert.assertEquals(loadedA.getId(), 2);
            Assert.assertEquals(loadedA.getVal(), "val2");
            Assert.assertTrue(loadedA instanceof TpcInheritA);
            Assert.assertEquals(((TpcInheritA) loadedA).getInhA(), "inhA");


            insertUpdateDelete(session, TpcInheritA.class, (TpcInheritA) loadedA, new UpdateCallback<TpcInheritA>() {
                @Override public void modify(TpcInheritA inst) {
                    Assert.assertTrue(inst instanceof TpcInheritA);
                }


                @Override public void check(TpcInheritA inst) {
                    Assert.assertTrue(inst instanceof TpcInheritA);
                    Assert.assertEquals(inst.getVal(), "val2");
                }
            }, 2);
            session.insert(loadedA);


            TpcBaseEntity loadedB = session.loadOne(TpcInheritB.class, 3);
            Assert.assertNotNull(loadedB);
            Assert.assertEquals(loadedB.getId(), 3);
            Assert.assertEquals(loadedB.getVal(), "val3");
            Assert.assertTrue(loadedB instanceof TpcInheritB);
            Assert.assertEquals(((TpcInheritB) loadedB).getInhB(), "inhB");


            insertUpdateDelete(session, TpcInheritB.class, (TpcInheritB) loadedB, new UpdateCallback<TpcInheritB>() {
                @Override public void modify(TpcInheritB inst) {
                    Assert.assertTrue(inst instanceof TpcInheritB);
                }


                @Override public void check(TpcInheritB inst) {
                    Assert.assertTrue(inst instanceof TpcInheritB);
                    Assert.assertEquals(inst.getVal(), "val3");
                }
            }, 3);
            session.insert(loadedB);


            TpcBaseEntity loadedB2 = session.loadOne(TpcInheritB2.class, 4);
            Assert.assertNotNull(loadedB2);
            Assert.assertEquals(loadedB2.getId(), 4);
            Assert.assertEquals(loadedB2.getVal(), "val4");
            Assert.assertTrue(loadedB2 instanceof TpcInheritB2);
            Assert.assertEquals(((TpcInheritB) loadedB2).getInhB(), "inhB");
            Assert.assertEquals(((TpcInheritB2) loadedB2).getInhB2(), "inhB2");


            insertUpdateDelete(session, TpcInheritB2.class, (TpcInheritB2) loadedB2, new UpdateCallback<TpcInheritB2>() {
                @Override public void modify(TpcInheritB2 inst) {
                    Assert.assertTrue(inst instanceof TpcInheritB2);
                }


                @Override public void check(TpcInheritB2 inst) {
                    Assert.assertTrue(inst instanceof TpcInheritB2);
                    Assert.assertEquals(inst.getVal(), "val4");
                }
            }, 4);
            session.insert(loadedB2);


            TpcBaseEntity loadedC = session.loadOne(TpcInheritC.class, 5);
            Assert.assertNotNull(loadedC);
            Assert.assertEquals(loadedC.getId(), 5);
            Assert.assertEquals(loadedC.getVal(), "val5");
            Assert.assertTrue(loadedC instanceof TpcInheritC);
            Assert.assertEquals(((TpcInheritC) loadedC).getInhC(), "inhC");


            insertUpdateDelete(session, TpcInheritC.class, (TpcInheritC) loadedC, new UpdateCallback<TpcInheritC>() {
                @Override public void modify(TpcInheritC inst) {
                    Assert.assertTrue(inst instanceof TpcInheritC);
                }


                @Override public void check(TpcInheritC inst) {
                    Assert.assertEquals(inst.getVal(), "val5");
                }
            }, 5);
            session.insert(loadedC);


            loadedB2 = session.loadOne(TpcInheritB.class, 4);
            Assert.assertNotNull(loadedB2);
            Assert.assertEquals(loadedB2.getId(), 4);
            Assert.assertEquals(loadedB2.getVal(), "val4");
            Assert.assertTrue(loadedB2 instanceof TpcInheritB2);
            Assert.assertEquals(((TpcInheritB) loadedB2).getInhB(), "inhB");
            Assert.assertEquals(((TpcInheritB2) loadedB2).getInhB2(), "inhB2");


            loadedA = session.loadOne(TpcBaseEntity.class, 2);
            Assert.assertNotNull(loadedA);
            Assert.assertEquals(loadedA.getId(), 2);
            Assert.assertEquals(loadedA.getVal(), "val2");
            Assert.assertTrue(loadedA instanceof TpcInheritA);
            Assert.assertEquals(((TpcInheritA) loadedA).getInhA(), "inhA");


            insertUpdateDelete(session, TpcBaseEntity.class, loadedA, new UpdateCallback<TpcBaseEntity>() {
                @Override public void modify(TpcBaseEntity inst) {
                    Assert.assertTrue(inst instanceof TpcInheritA);
                }


                @Override public void check(TpcBaseEntity inst) {
                    Assert.assertTrue(inst instanceof TpcInheritA);
                    Assert.assertEquals(inst.getVal(), "val2");
                }
            }, 2);


            loadedB = session.loadOne(TpcBaseEntity.class, 3);
            Assert.assertNotNull(loadedB);
            Assert.assertEquals(loadedB.getId(), 3);
            Assert.assertEquals(loadedB.getVal(), "val3");
            Assert.assertTrue(loadedB instanceof TpcInheritB);
            Assert.assertEquals(((TpcInheritB) loadedB).getInhB(), "inhB");


            insertUpdateDelete(session, TpcBaseEntity.class, loadedB, new UpdateCallback<TpcBaseEntity>() {
                @Override public void modify(TpcBaseEntity inst) {
                    Assert.assertTrue(inst instanceof TpcInheritB);
                }


                @Override public void check(TpcBaseEntity inst) {
                    Assert.assertTrue(inst instanceof TpcInheritB);
                    Assert.assertEquals(inst.getVal(), "val3");
                }
            }, 3);


            loadedB2 = session.loadOne(TpcBaseEntity.class, 4);
            Assert.assertNotNull(loadedB2);
            Assert.assertEquals(loadedB2.getId(), 4);
            Assert.assertEquals(loadedB2.getVal(), "val4");
            Assert.assertTrue(loadedB2 instanceof TpcInheritB2);
            Assert.assertEquals(((TpcInheritB) loadedB2).getInhB(), "inhB");
            Assert.assertEquals(((TpcInheritB2) loadedB2).getInhB2(), "inhB2");


            insertUpdateDelete(session, TpcBaseEntity.class, loadedB2, new UpdateCallback<TpcBaseEntity>() {
                @Override public void modify(TpcBaseEntity inst) {
                    Assert.assertTrue(inst instanceof TpcInheritB2);
                }


                @Override public void check(TpcBaseEntity inst) {
                    Assert.assertTrue(inst instanceof TpcInheritB2);
                    Assert.assertEquals(inst.getVal(), "val4");
                }
            }, 4);


            loadedC = session.loadOne(TpcBaseEntity.class, 5);
            Assert.assertNotNull(loadedC);
            Assert.assertEquals(loadedC.getId(), 5);
            Assert.assertEquals(loadedC.getVal(), "val5");
            Assert.assertTrue(loadedC instanceof TpcInheritC);
            Assert.assertEquals(((TpcInheritC) loadedC).getInhC(), "inhC");


            insertUpdateDelete(session, TpcBaseEntity.class, loadedC, new UpdateCallback<TpcBaseEntity>() {
                @Override public void modify(TpcBaseEntity inst) {
                    Assert.assertTrue(inst instanceof TpcInheritC);
                }


                @Override public void check(TpcBaseEntity inst) {
                    Assert.assertTrue(inst instanceof TpcInheritC);
                    Assert.assertEquals(inst.getVal(), "val5");
                }
            }, 5);


            //
            //
            //


            instBase = new TpcBaseEntity();
            instBase.setId(1);
            instBase.setCid(1);
            instBase.setVal("val1");
            session.insert(instBase);


            instA = new TpcInheritA();
            instA.setId(1);
            instA.setCid(2);
            instA.setVal("val2");
            instA.setInhA("inhA");
            session.insert(instA);


            instB = new TpcInheritB();
            instB.setId(1);
            instB.setCid(3);
            instB.setVal("val3");
            instB.setInhB("inhB");
            session.insert(instB);


            instB2 = new TpcInheritB2();
            instB2.setId(1);
            instB2.setCid(4);
            instB2.setVal("val4");
            instB2.setInhB("inhB");
            instB2.setInhB2("inhB2");
            session.insert(instB2);


            instC = new TpcInheritC();
            instC.setId(1);
            instC.setCid(5);
            instC.setVal("val5");
            instC.setInhC("inhC");
            session.insert(instC);


            List<TpcBaseEntity> multiple = session.loadMultiple(TpcBaseEntity.class, 1);
            Assert.assertNotNull(multiple);
            Assert.assertEquals(multiple.size(), 5);


            List<TpcBaseEntity> none = session.loadMultiple(TpcBaseEntity.class, 0);
            Assert.assertNotNull(none);
            Assert.assertEquals(none.size(), 0);


        } finally {session.close();}
    }

View Full Code Here

        waitEntityAvailable(entityB);
        waitEntityAvailable(entityB2);
        waitEntityAvailable(entityB3);
        waitEntityAvailable(entityC);


        PersistenceSession session = persistenceManager.createSession();
        try {


            Tpc2InheritA instA = new Tpc2InheritA();
            instA.setId(2);
            instA.setCid(1);
            instA.setVal("val2");
            instA.setInhA("inhA");
            session.insert(instA);


            Tpc2InheritB2 instB2 = new Tpc2InheritB2();
            instB2.setId(4);
            instB2.setCid(1);
            instB2.setVal("val4");
            instB2.setInhB("inhB");
            instB2.setInhB2("inhB2");
            session.insert(instB2);


            Tpc2InheritB3 instB3 = new Tpc2InheritB3();
            instB3.setId(6);
            instB3.setCid(1);
            instB3.setVal("val4");
            instB3.setInhB("inhB");
            instB3.setInhB2("inhB2");
            session.insert(instB2);


            Tpc2InheritC instC = new Tpc2InheritC();
            instC.setId(5);
            instC.setCid(1);
            instC.setVal("val5");
            instC.setInhC("inhC");
            session.insert(instC);


            Tpc2BaseEntity loadedA = session.loadOne(Tpc2InheritA.class, 2);
            Assert.assertNotNull(loadedA);
            Assert.assertEquals(loadedA.getId(), 2);
            Assert.assertEquals(loadedA.getVal(), "val2");
            Assert.assertTrue(loadedA instanceof Tpc2InheritA);
            Assert.assertEquals(((Tpc2InheritA) loadedA).getInhA(), "inhA");


            insertUpdateDelete(session, Tpc2InheritA.class, (Tpc2InheritA) loadedA, new UpdateCallback<Tpc2InheritA>() {
                @Override public void modify(Tpc2InheritA inst) {
                    Assert.assertTrue(inst instanceof Tpc2InheritA);
                }


                @Override public void check(Tpc2InheritA inst) {
                    Assert.assertTrue(inst instanceof Tpc2InheritA);
                    Assert.assertEquals(inst.getVal(), "val2");
                }
            }, 2);
            session.insert(loadedA);


            Tpc2BaseEntity loadedB2 = session.loadOne(Tpc2InheritB2.class, 4);
            Assert.assertNotNull(loadedB2);
            Assert.assertEquals(loadedB2.getId(), 4);
            Assert.assertEquals(loadedB2.getVal(), "val4");
            Assert.assertTrue(loadedB2 instanceof Tpc2InheritB2);
            Assert.assertEquals(((Tpc2InheritB) loadedB2).getInhB(), "inhB");
            Assert.assertEquals(((Tpc2InheritB2) loadedB2).getInhB2(), "inhB2");


            insertUpdateDelete(session, Tpc2InheritB2.class, (Tpc2InheritB2) loadedB2, new UpdateCallback<Tpc2InheritB2>() {
                @Override public void modify(Tpc2InheritB2 inst) {
                    Assert.assertTrue(inst instanceof Tpc2InheritB2);
                }


                @Override public void check(Tpc2InheritB2 inst) {
                    Assert.assertTrue(inst instanceof Tpc2InheritB2);
                    Assert.assertEquals(inst.getVal(), "val4");
                }
            }, 4);
            session.insert(loadedB2);


            Tpc2BaseEntity loadedC = session.loadOne(Tpc2InheritC.class, 5);
            Assert.assertNotNull(loadedC);
            Assert.assertEquals(loadedC.getId(), 5);
            Assert.assertEquals(loadedC.getVal(), "val5");
            Assert.assertTrue(loadedC instanceof Tpc2InheritC);
            Assert.assertEquals(((Tpc2InheritC) loadedC).getInhC(), "inhC");


            insertUpdateDelete(session, Tpc2InheritC.class, (Tpc2InheritC) loadedC, new UpdateCallback<Tpc2InheritC>() {
                @Override public void modify(Tpc2InheritC inst) {
                    //inst.setStr("422");
                }


                @Override public void check(Tpc2InheritC inst) {
                    Assert.assertEquals(inst.getVal(), "val5");
                }
            }, 5);
            session.insert(loadedC);


            loadedB2 = session.loadOne(Tpc2InheritB.class, 4);
            Assert.assertNotNull(loadedB2);
            Assert.assertEquals(loadedB2.getId(), 4);
            Assert.assertEquals(loadedB2.getVal(), "val4");
            Assert.assertTrue(loadedB2 instanceof Tpc2InheritB2);
            Assert.assertEquals(((Tpc2InheritB) loadedB2).getInhB(), "inhB");
            Assert.assertEquals(((Tpc2InheritB2) loadedB2).getInhB2(), "inhB2");


            loadedA = session.loadOne(Tpc2BaseEntity.class, 2);
            Assert.assertNotNull(loadedA);
            Assert.assertEquals(loadedA.getId(), 2);
            Assert.assertEquals(loadedA.getVal(), "val2");
            Assert.assertTrue(loadedA instanceof Tpc2InheritA);
            Assert.assertEquals(((Tpc2InheritA) loadedA).getInhA(), "inhA");


            insertUpdateDelete(session, Tpc2BaseEntity.class, loadedA, new UpdateCallback<Tpc2BaseEntity>() {
                @Override public void modify(Tpc2BaseEntity inst) {
                    Assert.assertTrue(inst instanceof Tpc2InheritA);
                }


                @Override public void check(Tpc2BaseEntity inst) {
                    Assert.assertTrue(inst instanceof Tpc2InheritA);
                    Assert.assertEquals(inst.getVal(), "val2");
                }
            }, 2);


            loadedB2 = session.loadOne(Tpc2BaseEntity.class, 4);
            Assert.assertNotNull(loadedB2);
            Assert.assertEquals(loadedB2.getId(), 4);
            Assert.assertEquals(loadedB2.getVal(), "val4");
            Assert.assertTrue(loadedB2 instanceof Tpc2InheritB2);
            Assert.assertEquals(((Tpc2InheritB) loadedB2).getInhB(), "inhB");
            Assert.assertEquals(((Tpc2InheritB2) loadedB2).getInhB2(), "inhB2");


            insertUpdateDelete(session, Tpc2BaseEntity.class, loadedB2, new UpdateCallback<Tpc2BaseEntity>() {
                @Override public void modify(Tpc2BaseEntity inst) {
                    Assert.assertTrue(inst instanceof Tpc2InheritB2);
                }


                @Override public void check(Tpc2BaseEntity inst) {
                    Assert.assertTrue(inst instanceof Tpc2InheritB2);
                    Assert.assertEquals(inst.getVal(), "val4");
                }
            }, 4);


            loadedC = session.loadOne(Tpc2BaseEntity.class, 5);
            Assert.assertNotNull(loadedC);
            Assert.assertEquals(loadedC.getId(), 5);
            Assert.assertEquals(loadedC.getVal(), "val5");
            Assert.assertTrue(loadedC instanceof Tpc2InheritC);
            Assert.assertEquals(((Tpc2InheritC) loadedC).getInhC(), "inhC");


            insertUpdateDelete(session, Tpc2BaseEntity.class, loadedC, new UpdateCallback<Tpc2BaseEntity>() {
                @Override public void modify(Tpc2BaseEntity inst) {
                    Assert.assertTrue(inst instanceof Tpc2InheritC);
                }


                @Override public void check(Tpc2BaseEntity inst) {
                    Assert.assertTrue(inst instanceof Tpc2InheritC);
                    Assert.assertEquals(inst.getVal(), "val5");
                }
            }, 5);


            //
            //
            //


            instA = new Tpc2InheritA();
            instA.setId(1);
            instA.setCid(2);
            instA.setVal("val2");
            instA.setInhA("inhA");
            session.insert(instA);


            instB2 = new Tpc2InheritB2();
            instB2.setId(1);
            instB2.setCid(4);
            instB2.setVal("val4");
            instB2.setInhB("inhB");
            instB2.setInhB2("inhB2");
            session.insert(instB2);


            instC = new Tpc2InheritC();
            instC.setId(1);
            instC.setCid(5);
            instC.setVal("val5");
            instC.setInhC("inhC");
            session.insert(instC);


            List<Tpc2BaseEntity> multiple = session.loadMultiple(Tpc2BaseEntity.class, 1);
            Assert.assertNotNull(multiple);
            Assert.assertEquals(multiple.size(), 3);


            List<Tpc2BaseEntity> none = session.loadMultiple(Tpc2BaseEntity.class, 0);
            Assert.assertNotNull(none);
            Assert.assertEquals(none.size(), 0);


        } finally {session.close();}
    }

View Full Code Here

    }


    @Test(dependsOnMethods = "createSchema")
    public void tracking_insertAndLoad() throws Exception {


        PersistenceSession session = persistenceManager.createTrackingSession();
        try {
            TrackingEntity inst = new TrackingEntity();
            inst.setId(11);
            inst.setStr("str");
            inst.setValue("val");
            session.insert(inst);


            TrackingEntity loaded = session.loadOne(TrackingEntity.class, 11);
            Assert.assertSame(loaded, inst);
        } finally {session.close();}
    }

View Full Code Here

0 1 2 3 4 5

TOP

Related Classes of org.caffinitas.mapper.core.PersistenceSession

org.caffinitas.mapper.converter.joda.test.JodaConvertTest

org.caffinitas.mapper.demo.Demo

org.caffinitas.mapper.test.attrover.AttrOverrideTest

org.caffinitas.mapper.test.batch.BatchCasTest

org.caffinitas.mapper.test.batch.BatchTest

org.caffinitas.mapper.test.composite.CompositeTest

org.caffinitas.mapper.test.dynamic.DynamicCompositeTest

org.caffinitas.mapper.test.lazy.LazyTest

org.caffinitas.mapper.test.mapentity.MapEntityTest

org.caffinitas.mapper.test.model.InheritanceTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.