Examples of org.conserve.PersistenceManager

org.conserve.PersistenceManager
Object database interface. Saves to and retrieves from a persistence database. This is the main programming interface class. Create an instance of this class to interact with the database. @author Erik Berglund

   * @throws Exception
   */
  @Test
  public void testInnerMatching() throws Exception
  {
    PersistenceManager persist = new PersistenceManager(driver, database, login, password);
    SimplestObject so = new SimplestObject();
    so.setFoo(1.0);
    ComplexObject co = new ComplexObject();
    co.setObject(so);
    persist.saveObject(co);
    // close the persistence object
    persist.close();


    // re-open the persistence object
    persist = new PersistenceManager(driver, database, login, password);
    // create a SimplestObject so that no results will match
    so = new SimplestObject();
    so.setFoo(2.0);
    // make sure this matches no results
    ComplexObject search = new ComplexObject();
    search.setObject(so);
    List<ComplexObject> none = persist.getObjectsMatching(search);
    assertEquals(0, none.size());
    // change the search so that one object is returned
    so.setFoo(1.0);
    List<ComplexObject> one = persist.getObjectsMatching(search);
    assertEquals(1, one.size());


    persist.close();


  }

View Full Code Here

   * @throws Exception
   */
  @Test
  public void testArrayMatching() throws Exception
  {
    PersistenceManager persist = new PersistenceManager(driver, database, login, password);
    // create a complex object with an Integer array as object
    Integer[] intArray = new Integer[] { 4, 5, 6 };
    ComplexObject co = new ComplexObject();
    co.setObject(intArray);
    persist.saveObject(co);
    // close the persistence object
    persist.close();


    // re-open the persistence object
    persist = new PersistenceManager(driver, database, login, password);
    // create an integer array where all entries but one is null
    Integer[] searchArray = new Integer[3];
    searchArray[2] = 7;
    // make sure this matches no results
    ComplexObject search = new ComplexObject();
    search.setObject(searchArray);
    List<ComplexObject> none = persist.getObjectsMatching(search);
    assertEquals(0, none.size());
    // change the search so that one object is returned
    searchArray[1] = 5;
    searchArray[2] = 6;
    List<ComplexObject> one = persist.getObjectsMatching(search);
    assertEquals(1, one.size());


    persist.close();
  }

View Full Code Here

   * 
   */
  @Test
  public void testInterfaceNonStrictQuery() throws Exception
  {
    PersistenceManager persist = new PersistenceManager(driver, database, login, password);


    // create two FooContainerOwner objects
    FooContainerOwner one = new FooContainerOwner();
    MyFooContainer fooer = new MyFooContainer();
    fooer.setFoo("oneFooer");
    one.setFooContainer(fooer);


    FooContainerOwner two = new FooContainerOwner();
    MyExtendedFooContainer extfooer = new MyExtendedFooContainer();
    extfooer.setFoo("twoFooer");
    two.setFooContainer(extfooer);


    // save FooContainerOwner objects.
    persist.saveObject(one);
    persist.saveObject(two);
    persist.close();


    // re-open connection
    persist = new PersistenceManager(driver, database, login, password);


    // check that there are two FooContainerOwners
    List<FooContainerOwner> fooableowners = persist.getObjects(FooContainerOwner.class, new All());
    assertEquals(2, fooableowners.size());


    // check that there are two FooContainers
    List<FooContainer> fooables = persist.getObjects(FooContainer.class, new All());
    assertEquals(2, fooables.size());
    // check that there is one ExtendedFooContainer
    List<ExtendedFooContainer> extendedfooables = persist.getObjects(ExtendedFooContainer.class, new All());
    assertEquals(1, extendedfooables.size());


    FooContainerOwner searchObject = new FooContainerOwner();


    // get the first foo based on strict search
    fooer = new MyFooContainer();
    fooer.setFoo("oneFooer");
    searchObject.setFooContainer(fooer);
    fooableowners = persist.getObjects(FooContainerOwner.class, new Equal(searchObject));
    assertEquals(1, fooableowners.size());


    // get second foo based on strict search
    extfooer = new MyExtendedFooContainer();
    extfooer.setFoo("twoFooer");
    searchObject.setFooContainer(extfooer);
    fooableowners = persist.getObjects(FooContainerOwner.class, new Equal(searchObject));
    assertEquals(1, fooableowners.size());


    // check that second foo can't be gotten by strict search
    fooer.setFoo("twoFooer");
    searchObject.setFooContainer(fooer);
    fooableowners = persist.getObjects(FooContainerOwner.class, new Equal(searchObject));
    assertEquals(0, fooableowners.size());


    // get second foo based on non-strict search
    fooableowners = persist.getObjects(FooContainerOwner.class, new Equal(searchObject, false));
    assertEquals(1, fooableowners.size());


    // check that the first foo can't be gotten by strict search
    extfooer.setFoo("oneFooer");
    searchObject.setFooContainer(extfooer);
    fooableowners = persist.getObjects(FooContainerOwner.class, new Equal(searchObject));
    assertEquals(0, fooableowners.size());


    // get first foo based on non-strict search
    fooableowners = persist.getObjects(FooContainerOwner.class, new Equal(searchObject, false));
    assertEquals(1, fooableowners.size());


    persist.close();
  }

View Full Code Here

   * @throws Exception
   */
  @Test
  public void testDropTable() throws Exception
  {
    PersistenceManager persist = new PersistenceManager(driver, database, login, password);
    // drop all tables
    persist.dropTable(Object.class);
    persist.close();
  }

View Full Code Here

   * 
   */
  @Test
  public void testRefresh() throws Exception
  {
    PersistenceManager persistOne = new PersistenceManager(driver, database, login, password);
    PersistenceManager persistTwo = new PersistenceManager(driver, database, login, password);
    // create a simple object
    SimpleObject so = new SimpleObject();
    so.setName("foo bar");


    // save the object
    persistOne.saveObject(so);


    // load the object from another instance
    List<SimpleObject> simpleObjects = persistTwo.getObjects(SimpleObject.class, new All());
    SimpleObject copy = simpleObjects.get(0);


    // alter the original object
    so.setName("altered");
    // save the altered object
    persistOne.saveObject(so);
    // update the copy
    SimpleObject copy2 = persistTwo.refresh(copy);
    // make sure the change has propagated
    assertEquals(so.getName(), copy.getName());
    assertEquals(copy.getName(), copy2.getName());
    assertEquals(copy, copy2);
  }

View Full Code Here

   */
  @Test
  public void testRefreshSelfReferencing() throws Exception
  {


    PersistenceManager persistOne = new PersistenceManager(driver, database, login, password);
    PersistenceManager persistTwo = new PersistenceManager(driver, database, login, password);
    // create recursive objects
    Layer1 layer1 = new Layer1();
    layer1.setName("foo bar");
    Layer2 layer2 = new Layer2();
    Layer3 layer3 = new Layer3();
    // connect objects
    layer1.setLayer2(layer2);
    layer2.setLayer3(layer3);
    layer3.setLayer1(layer1);


    // save the objects
    persistOne.saveObject(layer1);


    // load the object from another instance
    List<Layer3> layer3s = persistTwo.getObjects(Layer3.class, new All());
    Layer3 copy = layer3s.get(0);


    // alter the original object
    layer3.getLayer1().setName("altered");
    // save the altered object
    persistOne.saveObject(layer3);
    // update the copy
    persistTwo.refresh(copy);
    // make sure the change has propagated
    assertEquals(layer3.getLayer1().getName(), copy.getLayer1().getName());
  }

View Full Code Here

   */
  @Test
  public void testDuplicate() throws Exception
  {
    // create two persistence managers
    PersistenceManager persistOne = new PersistenceManager(driver, database, login, password);
    if (secondDatabase == null)
    {
      secondDatabase = database + "2";
    }
    PersistenceManager persistTwo = new PersistenceManager(driver, secondDatabase, login, password);


    // drop all tables in both
    persistOne.dropTable(Object.class);
    persistTwo.dropTable(Object.class);
    // create some objects in the first database
    ComplexObject co = new ComplexObject();
    co.setData(new double[] { 1, 2, 3 });
    co.setSimplestObject(new SimplestObject(5.0));
    persistOne.saveObject(co);
    LessSimpleObject lso = new LessSimpleObject();
    lso.setAge(50L);
    lso.setName("name");
    lso.setValue(6);
    persistOne.saveObject(lso);


    // peform a copy
    persistOne.duplicate(persistTwo);
    // close both persistence managers
    persistOne.close();
    persistTwo.close();


    // re-open the target persistence manager
    persistTwo = new PersistenceManager(driver, secondDatabase, login, password);
    // assert that there is 3 objects in all
    List<Object> allObjects = persistTwo.getObjects(Object.class, new All());
    assertEquals(3, allObjects.size());
    // assert that there is one LessSimpleObject
    List<LessSimpleObject> lessSimpleObjects = persistTwo.getObjects(LessSimpleObject.class, new All());
    assertEquals(1, lessSimpleObjects.size());
    // assert that the LessSimpleObject has "name" as name.
    LessSimpleObject first = lessSimpleObjects.get(0);
    assertEquals("name", first.getName());
  }

View Full Code Here

   */
  @Test
  public void testCalendar() throws Exception
  {


    PersistenceManager persist = new PersistenceManager(driver, database, login, password);
    GregorianCalendar cal = new GregorianCalendar(1999, 9, 9);


    // GregorianCalendar will throw exception if some fields are accessed
    // before others
    Date d = cal.getTime();
    System.out.println(d);


    // save the calendar
    persist.saveObject(cal);


    List<Calendar> cals = persist.getObjects(Calendar.class, new All());


    // verify that we have at least one calendar stored
    assertTrue(cals.size() > 0);


    persist.close();
  }

View Full Code Here

  {
    String name = "foo";
    int value = 42;
    Object otherObject = new SimpleObject();
    Object redundantObject = new SimplestObject();
    PersistenceManager pm = new PersistenceManager(driver, database, login, password);
    // drop all tables
    pm.dropTable(Object.class);


    // create and store a new value
    OriginalObject oo = new OriginalObject();
    oo.setName(name);
    oo.setValue(value);
    oo.setOtherObject(otherObject);
    oo.setRedundantObject(redundantObject);
    pm.saveObject(oo);
    // rename the table
    pm.changeName(OriginalObject.class, NewName.class);
    // get all NewName objects
    List<NewName> res = pm.getObjects(NewName.class, new All());
    assertEquals(res.size(), 1);
    // make sure all properties match
    NewName nn = res.get(0);
    assertEquals(nn.getValue(), value);
    assertEquals(nn.getName(), name);
    assertEquals(nn.getOtherObject(), otherObject);
    assertEquals(nn.getRedundantObject(), redundantObject);
    pm.close();


  }

View Full Code Here

  {
    String name = "foo";
    int value = 42;
    Object otherObject = new SimpleObject();
    Object redundantObject = new SimplestObject();
    PersistenceManager pm = new PersistenceManager(driver, database, login, password);
    // drop all tables
    pm.dropTable(Object.class);


    // create and store a new value
    OriginalObject oo = new OriginalObject();
    oo.setName(name);
    oo.setValue(value);
    oo.setOtherObject(otherObject);
    oo.setRedundantObject(redundantObject);
    pm.saveObject(oo);
    // rename the table
    pm.changeName(OriginalObject.class, RenamedColumn.class);
    // update schema
    pm.renameProperties(RenamedColumn.class);


    // get all RenamedColumn objects
    List<RenamedColumn> res1 = pm.getObjects(RenamedColumn.class, new All());
    assertEquals(res1.size(), 1);
    // make sure all properties match
    RenamedColumn nn = res1.get(0);
    assertEquals(value, nn.getValue());
    assertEquals(name, nn.getName());
    assertEquals(otherObject, nn.getOtherObject());
    assertEquals(redundantObject, nn.getRenamedObject());


    // change everything back
    pm.changeName(RenamedColumn.class, OriginalObject.class);
    pm.renameProperties(OriginalObject.class);


    // get all OriginalObject objects
    List<OriginalObject> res2 = pm.getObjects(OriginalObject.class, new All());
    assertEquals(res2.size(), 1);
    // make sure all properties match
    oo = res2.get(0);
    assertEquals(value, oo.getValue());
    assertEquals(name, oo.getName());
    assertEquals(otherObject, oo.getOtherObject());
    // make sure the column that has been renamed is preserved
    assertEquals(redundantObject, oo.getRedundantObject());


    pm.close();
  }

View Full Code Here

0 1 2 3 4 5

TOP

Related Classes of org.conserve.PersistenceManager

org.conserve.connection.ConnectionWrapper

org.conserve.PersistTest

org.conserve.select.All

org.conserve.select.discriminators.Equal

java.io.InputStream

java.io.File

java.io.FileInputStream

java.util.Properties

java.sql.SQLException

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.