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}.

    }


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


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


            loaded.setStr("updated");
            session.update(loaded);


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

View Full Code Here


        NoDataColumnsEntity inst = new NoDataColumnsEntity();
        inst.setId(11);
        inst.setStr("foo");


        PersistenceSession session = persistenceManager.createSession();
        try {
            session.insert(inst);


            NoDataColumnsEntity loaded = session.loadOne(NoDataColumnsEntity.class, 11, "foo");


            Assert.assertNotNull(loaded);
            Assert.assertEquals(loaded.getId(), 11);
            Assert.assertEquals(loaded.getStr(), "foo");


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


                @Override public void check(NoDataColumnsEntity inst) {
                    Assert.assertEquals(inst.getStr(), "foo");
                }
            }, 11);


            session.insert(inst);
            inst.setStr("bar");
            session.insert(inst);


            List<NoDataColumnsEntity> many = session.loadMultiple(NoDataColumnsEntity.class, 11);
            Assert.assertNotNull(many);
            Assert.assertEquals(many.size(), 2);
            Assert.assertEquals(many.get(0).getStr(), "bar");
            Assert.assertEquals(many.get(1).getStr(), "foo");
        } finally { session.close(); }
    }

View Full Code Here

        CollEntity inst = new CollEntity();
        inst.setId(11);
        inst.setStringList(Arrays.asList("one", "two", "three"));
        inst.setStringSet(new HashSet<String>(inst.getStringList()));


        PersistenceSession session = persistenceManager.createSession();
        try {
            session.insert(inst);


            CollEntity loaded = session.loadOne(CollEntity.class, 11);


            Assert.assertNotNull(loaded);
            Assert.assertEquals(loaded.getId(), 11);
            Assert.assertNotNull(loaded.getStringList());
            Assert.assertNotNull(loaded.getStringSet());
            Assert.assertEquals(loaded.getStringList(), Arrays.asList("one", "two", "three"));
            Assert.assertEquals(loaded.getStringSet(), new HashSet<String>(Arrays.asList("one", "two", "three")));


            insertUpdateDelete(session, CollEntity.class, inst, new UpdateCallback<CollEntity>() {
                @Override public void modify(CollEntity inst) {
                    inst.setStringList(Arrays.asList("eins", "zwei", "drei"));
                }


                @Override public void check(CollEntity inst) {
                    Assert.assertEquals(inst.getStringList(), Arrays.asList("eins", "zwei", "drei"));
                }
            }, 11);
        } finally {session.close();}
    }

View Full Code Here

        inst.getIntEnumMap().put(2, SomeEnum.TWO);
        inst.getIntEnumMap().put(3, SomeEnum.THREE);
        inst.getStringInetMap().put("localhost", InetAddress.getLocalHost());
        inst.getStringInetMap().put("loopback", InetAddress.getByName("localhost"));


        PersistenceSession session = persistenceManager.createSession();
        try {
            session.insert(inst);


            MapEntity loaded = session.loadOne(MapEntity.class, 11);


            Assert.assertNotNull(loaded);
            Assert.assertEquals(loaded.getId(), 11);
            Assert.assertNotNull(loaded.getIntEnumMap());
            Assert.assertNotNull(loaded.getStringInetMap());
            Assert.assertEquals(loaded.getIntEnumMap().size(), 3);
            Assert.assertEquals(loaded.getStringInetMap().size(), 2);
            Assert.assertEquals(loaded.getIntEnumMap().get(1), SomeEnum.ONE);
            Assert.assertEquals(loaded.getIntEnumMap().get(2), SomeEnum.TWO);
            Assert.assertEquals(loaded.getIntEnumMap().get(3), SomeEnum.THREE);
            Assert.assertEquals(loaded.getStringInetMap().get("localhost"), InetAddress.getLocalHost());
            Assert.assertEquals(loaded.getStringInetMap().get("loopback"), InetAddress.getByName("localhost"));


            insertUpdateDelete(session, MapEntity.class, inst, new UpdateCallback<MapEntity>() {
                @Override public void modify(MapEntity inst) throws Exception {
                    inst.getIntEnumMap().put(4, SomeEnum.ONE);
                    inst.getIntEnumMap().put(5, SomeEnum.TWO);
                    inst.getIntEnumMap().put(6, SomeEnum.THREE);
                    inst.getStringInetMap().put("A", InetAddress.getLocalHost());
                    inst.getStringInetMap().put("B", InetAddress.getByName("localhost"));
                }


                @Override public void check(MapEntity inst) throws Exception {
                    Assert.assertEquals(inst.getId(), 11);
                    Assert.assertNotNull(inst.getIntEnumMap());
                    Assert.assertNotNull(inst.getStringInetMap());
                    Assert.assertEquals(inst.getIntEnumMap().size(), 6);
                    Assert.assertEquals(inst.getStringInetMap().size(), 4);
                    Assert.assertEquals(inst.getIntEnumMap().get(1), SomeEnum.ONE);
                    Assert.assertEquals(inst.getIntEnumMap().get(2), SomeEnum.TWO);
                    Assert.assertEquals(inst.getIntEnumMap().get(3), SomeEnum.THREE);
                    Assert.assertEquals(inst.getStringInetMap().get("localhost"), InetAddress.getLocalHost());
                    Assert.assertEquals(inst.getStringInetMap().get("loopback"), InetAddress.getByName("localhost"));
                    Assert.assertEquals(inst.getIntEnumMap().get(4), SomeEnum.ONE);
                    Assert.assertEquals(inst.getIntEnumMap().get(5), SomeEnum.TWO);
                    Assert.assertEquals(inst.getIntEnumMap().get(6), SomeEnum.THREE);
                    Assert.assertEquals(inst.getStringInetMap().get("A"), InetAddress.getLocalHost());
                    Assert.assertEquals(inst.getStringInetMap().get("B"), InetAddress.getByName("localhost"));
                }
            }, 11);
        } finally { session.close(); }
    }

View Full Code Here

        flatComposite.setNext(next);
        flatComposite.setStr("some string value");
        flatComposite.setVint(42);
        inst.setFlatComposite(flatComposite);


        PersistenceSession session = persistenceManager.createSession();
        try {
            session.insert(inst);


            FlatCompEntity loaded = session.loadOne(FlatCompEntity.class, 11);


            Assert.assertNotNull(loaded);
            Assert.assertEquals(loaded.getId(), 11);


            flatComposite = loaded.getFlatComposite();
            Assert.assertNotNull(flatComposite);
            Assert.assertEquals(flatComposite.getStr(), "some string value");
            Assert.assertEquals(flatComposite.getVint(), 42);


            next = flatComposite.getNext();
            Assert.assertNotNull(next);
            Assert.assertEquals(next.getValA(), 7.51973d, .01d);
            Assert.assertEquals(next.getTs(), date);


            insertUpdateDelete(session, FlatCompEntity.class, inst, new UpdateCallback<FlatCompEntity>() {
                @Override public void modify(FlatCompEntity inst) {
                    inst.getFlatComposite().setStr("other string value");
                }


                @Override public void check(FlatCompEntity inst) {
                    Assert.assertEquals(inst.getFlatComposite().getStr(), "other string value");
                }
            }, 11);
        } finally { session.close(); }
    }

View Full Code Here

        Assert.assertEquals(otherFull.getAttributeNames().size(), 7);
        Assert.assertEquals(entity.getAllColumns().length, 8);
        Assert.assertEquals(otherSimple.getAllColumns().length, 3);
        Assert.assertEquals(otherFull.getAllColumns().length, 7);


        PersistenceSession session = persistenceManager.createSession();
        try {


            RefBySimplePKEntity refSimple = new RefBySimplePKEntity();
            refSimple.setId("idSimple");
            refSimple.setNum(42);
            refSimple.setValue("valSimple");
            session.insert(refSimple);


            final RefBySimplePKEntity refSimple2 = new RefBySimplePKEntity();
            refSimple2.setId("otherId");
            refSimple2.setNum(422);
            refSimple2.setValue("valSimple2");
            session.insert(refSimple2);


            RefByFullPKEntity refFull = new RefByFullPKEntity();
            refFull.setPk1("pk1");
            refFull.setPk2(2);
            refFull.setCk1(3);
            refFull.setCk2("ck2");
            refFull.setCk3(new Date());
            refFull.setValue("valFull");
            refFull.setNum(43);
            session.insert(refFull);


            ReferenceEntity inst = new ReferenceEntity();
            inst.setId(99);
            inst.setStr("str");
            session.insert(inst);


            inst = new ReferenceEntity();
            inst.setId(98);
            inst.setStr("str");
            inst.setOtherFull(refFull);
            inst.setOtherSimple(refSimple);
            session.insert(inst);


            ReferenceEntity loaded = session.loadOne(ReferenceEntity.class, 99);
            Assert.assertEquals(loaded.getId(), 99);
            Assert.assertEquals(loaded.getStr(), "str");
            Assert.assertNull(loaded.getOtherFull());
            Assert.assertNull(loaded.getOtherSimple());


            loaded = session.loadOne(ReferenceEntity.class, 98);
            Assert.assertEquals(loaded.getId(), 98);
            Assert.assertEquals(loaded.getStr(), "str");


            Assert.assertNotNull(loaded.getOtherSimple());
            Assert.assertEquals(loaded.getOtherSimple().getId(), "idSimple");
            Assert.assertEquals(loaded.getOtherSimple().getNum(), 42);
            Assert.assertEquals(loaded.getOtherSimple().getValue(), "valSimple");


            Assert.assertNotNull(loaded.getOtherFull());
            Assert.assertEquals(loaded.getOtherFull().getPk1(), "pk1");
            Assert.assertEquals(loaded.getOtherFull().getPk2(), 2);
            Assert.assertEquals(loaded.getOtherFull().getCk1(), 3);
            Assert.assertEquals(loaded.getOtherFull().getCk2(), "ck2");
            Assert.assertEquals(loaded.getOtherFull().getCk3(), refFull.getCk3());
            Assert.assertEquals(loaded.getOtherFull().getValue(), "valFull");
            Assert.assertEquals(loaded.getOtherFull().getNum(), 43);


            insertUpdateDelete(session, ReferenceEntity.class, inst, new UpdateCallback<ReferenceEntity>() {
                @Override public void modify(ReferenceEntity inst) {
                    inst.setOtherSimple(refSimple2);
                }


                @Override public void check(ReferenceEntity inst) {
                    Assert.assertEquals(inst.getOtherSimple().getId(), "otherId");
                    Assert.assertEquals(inst.getOtherSimple().getNum(), 422);
                    Assert.assertEquals(inst.getOtherSimple().getValue(), "valSimple2");
                }
            }, 98);
        } finally { session.close(); }
    }

View Full Code Here

        inner.setNext(next);
        inner.setStr("some string value");
        inner.setVint(42);
        inst.setInner(inner);


        PersistenceSession session = persistenceManager.createSession();
        try {
            session.insert(inst);


            DenormEntity loaded = session.loadOne(DenormEntity.class, 11);


            Assert.assertNotNull(loaded);
            Assert.assertEquals(loaded.getId(), 11);


            inner = loaded.getInner();
            Assert.assertNotNull(inner);
            Assert.assertEquals(inner.getStr(), "some string value");
            Assert.assertEquals(inner.getVint(), 42);


            next = inner.getNext();
            Assert.assertNotNull(next);
            Assert.assertEquals(next.getValA(), 7.51973d, .01d);
            Assert.assertEquals(next.getTs(), date);


            insertUpdateDelete(session, DenormEntity.class, inst, new UpdateCallback<DenormEntity>() {
                @Override public void modify(DenormEntity inst) {
                    DenormInnerEntity inner = new DenormInnerEntity();
                    inner.setStr("other string value");
                    inner.setVint(422);
                    inst.setInner(inner);
                }


                @Override public void check(DenormEntity inst) {
                    Assert.assertEquals(inst.getInner().getVint(), 422);
                    Assert.assertEquals(inst.getInner().getStr(), "other string value");
                }
            }, 11);
        } finally { session.close(); }
    }

View Full Code Here

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


    @Test(dependsOnMethods = "createSchema")
    public void batch_simple() throws Exception {
        PersistenceSession session = persistenceManager.createSession();
        try {
            Batch batch = session.startBatch();
            try {


                BatchEntity inst = new BatchEntity();
                inst.setId(1);
                inst.setVal("1");
                batch.insert(inst);


                inst = new BatchEntity();
                inst.setId(2);
                inst.setVal("2");
                batch.insert(inst);


                inst = new BatchEntity();
                inst.setId(3);
                inst.setVal("3");
                batch.insert(inst);
            } finally { batch.close(); } // Batch.close() implicitly calls Batch.submitBatch()


            BatchEntity loaded = session.loadOne(BatchEntity.class, 1);
            Assert.assertNotNull(loaded);
            Assert.assertEquals(loaded.getVal(), "1");
            loaded = session.loadOne(BatchEntity.class, 2);
            Assert.assertNotNull(loaded);
            Assert.assertEquals(loaded.getVal(), "2");
            loaded = session.loadOne(BatchEntity.class, 3);
            Assert.assertNotNull(loaded);
            Assert.assertEquals(loaded.getVal(), "3");
        } finally {session.close();}
    }

View Full Code Here

        Assert.assertEquals(14, entity.getAllColumns().length);
        Assert.assertEquals(14, entity.getReadColumns().length);
        Assert.assertEquals(8, entity.getWriteColumns().length);
        Assert.assertEquals(13, entity.getReadDataColumns().length);


        PersistenceSession session = persistenceManager.createSession();
        try {
            MetaEntity inst = new MetaEntity();
            inst.setId(11);
            inst.setStr("some str");
            inst.setIntObj(1701);
            inst.setIntPrim(42);
            session.insert(inst);


            MetaEntity loaded = session.loadOne(MetaEntity.class, 11);


            Assert.assertNotNull(loaded);
            Assert.assertEquals(loaded.getId(), 11);
            Assert.assertEquals(loaded.getStr(), "some str");
            Assert.assertEquals(loaded.getIntObj(), Integer.valueOf(1701));
            Assert.assertEquals(loaded.getIntPrim(), 42);


            Date intObjWritetime = loaded.getIntObjWritetime();
            Date strWritetime = loaded.getStrWritetime();
            Date someEnum1Writetime = loaded.getSomeEnum1Writetime();


            Assert.assertNull(loaded.getIntObjTTL());
            Assert.assertNotNull(intObjWritetime);
            Assert.assertNull(loaded.getStrTTL());
            Assert.assertNotNull(strWritetime);
            Assert.assertNull(loaded.getSomeEnum1TTL());
            Assert.assertNull(someEnum1Writetime);


            Thread.sleep(100L);


            inst.setStr("other");
            inst.setIntObj(1702);
            inst.setIntPrim(43);
            session.insert(inst);


            loaded = session.loadOne(MetaEntity.class, 11);


            Assert.assertNotNull(loaded);
            Assert.assertEquals(loaded.getId(), 11);
            Assert.assertEquals(loaded.getStr(), "other");
            Assert.assertEquals(loaded.getIntObj(), Integer.valueOf(1702));
            Assert.assertEquals(loaded.getIntPrim(), 43);


            final Date intObjWritetime2 = loaded.getIntObjWritetime();
            final Date strWritetime2 = loaded.getStrWritetime();
            Date someEnum1Writetime2 = loaded.getSomeEnum1Writetime();


            Assert.assertNull(loaded.getIntObjTTL());
            Assert.assertNotNull(intObjWritetime2);
            Assert.assertNull(loaded.getStrTTL());
            Assert.assertNotNull(strWritetime2);
            Assert.assertNull(loaded.getSomeEnum1TTL());
            Assert.assertNull(someEnum1Writetime2);


            Assert.assertTrue(intObjWritetime2.getTime() > intObjWritetime.getTime());
            Assert.assertTrue(strWritetime2.getTime() > strWritetime.getTime());


            Thread.sleep(100L);


            insertUpdateDelete(session, MetaEntity.class, inst, new UpdateCallback<MetaEntity>() {
                @Override public void modify(MetaEntity inst) {
                    inst.setStr("other");
                    inst.setIntObj(1702);
                    inst.setIntPrim(43);
                }


                @Override public void check(MetaEntity inst) {


                    Date intObjWritetime3 = inst.getIntObjWritetime();
                    Date strWritetime3 = inst.getStrWritetime();
                    Date someEnum1Writetime3 = inst.getSomeEnum1Writetime();


                    Assert.assertNull(inst.getIntObjTTL());
                    Assert.assertNotNull(intObjWritetime3);
                    Assert.assertNull(inst.getStrTTL());
                    Assert.assertNotNull(strWritetime3);
                    Assert.assertNull(inst.getSomeEnum1TTL());
                    Assert.assertNull(someEnum1Writetime3);


                    Assert.assertTrue(intObjWritetime3.getTime() > intObjWritetime2.getTime());
                    Assert.assertTrue(strWritetime3.getTime() > strWritetime2.getTime());
                }
            }, 11);
        } finally { session.close(); }
    }

View Full Code Here

        inst.setPk2("part key part");
        inst.setCk1(date);
        inst.setCk2("clustering part");
        inst.setValue(42);


        PersistenceSession session = persistenceManager.createSession();
        try {
            session.insert(inst);


            ClustKeyEntity loaded = session.loadOne(ClustKeyEntity.class, uuid, "part key part", date, "clustering part");


            Assert.assertNotNull(loaded);
            Assert.assertEquals(loaded.getPk1(), uuid);
            Assert.assertEquals(loaded.getPk2(), "part key part");
            Assert.assertEquals(loaded.getCk1(), date);
            Assert.assertEquals(loaded.getCk2(), "clustering part");
            Assert.assertEquals(loaded.getValue(), 42);


            insertUpdateDelete(session, ClustKeyEntity.class, inst, new UpdateCallback<ClustKeyEntity>() {
                @Override public void modify(ClustKeyEntity inst) {
                    inst.setValue(422);
                }


                @Override public void check(ClustKeyEntity inst) {
                    Assert.assertEquals(inst.getValue(), 422);
                }
            }, uuid, "part key part", date, "clustering part");
        } 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.