Java Datastore.update方法代碼示例

import org.mongodb.morphia.Datastore; //導入方法依賴的package包/類
@Test
public void testVersionsWithUpdate() {
    final ALongPrimitive initial = new ALongPrimitive();
    Datastore ds = getDs();
    ds.save(initial);

    Query<ALongPrimitive> query = ds.find(ALongPrimitive.class)
                                 .field("id").equal(initial.getId());
    UpdateOperations<ALongPrimitive> update = ds.createUpdateOperations(ALongPrimitive.class)
                                                .set("text", "some new value");
    UpdateResults results = ds.update(query, update);
    assertEquals(1, results.getUpdatedCount());
    ALongPrimitive postUpdate = ds.get(ALongPrimitive.class, initial.getId());

    Assert.assertEquals(initial.version + 1, postUpdate.version);
}
 

import org.mongodb.morphia.Datastore; //導入方法依賴的package包/類
public void deleteAuthorReferences(Author author) {

		Datastore ds = getDatastore();

		UpdateOperations<Post> ops = ds.createUpdateOperations(Post.class)
				.unset("author");
		ds.update(ds.createQuery(Post.class).field("author").equal(author), ops);
	}
 

import org.mongodb.morphia.Datastore; //導入方法依賴的package包/類
public static boolean changeIssue(String _id,String title, String info,
		String requirement, String specialty, String total) {
	try {
		Datastore ds = MongoDBUtil.getDatastore();
		ds.update(ds.find(Issue.class).filter("_id", new ObjectId(_id)),
				ds.createUpdateOperations(Issue.class)
				.set("title", title).set("info", info).set("requirement", requirement)
				.set("specialty", specialty).set("total", total));
				
		return true;
	} catch (Exception e) {
		e.printStackTrace();
		return false;
	}
}
 

import org.mongodb.morphia.Datastore; //導入方法依賴的package包/類
public static String selectSubject(String title){
	Datastore ds = MongoDBUtil.getDatastore();
	Issue issue=ds.find(Issue.class).filter("title", title).get();
	if(issue.getRemain()>0){
		ds.update(issue, 
				ds.createUpdateOperations(Issue.class).set("remain", issue.getRemain()-1));
		return issue.getTeacher();
	}
	else return null;
}
 

import org.mongodb.morphia.Datastore; //導入方法依賴的package包/類
public static boolean addSubject(String no, String firstChoice,
		String secondChoice, String thirdChoice) {
	try {
		String teacher;
		Datastore ds = MongoDBUtil.getDatastore();
		ds.update(
				ds.find(Student.class).filter("no", no),
				ds.createUpdateOperations(Student.class)
						.set("firstChoice", firstChoice)
						.set("secondChoice", secondChoice)
						.set("thirdChoice", thirdChoice));
		if((teacher=IssueDAO.selectSubject(firstChoice))!=null){
			ds.update(
					ds.find(Student.class).filter("no", no),
					ds.createUpdateOperations(Student.class)
							.set("teacher", teacher).set("issue", firstChoice));
		}else if((teacher=IssueDAO.selectSubject(secondChoice))!=null){
			ds.update(
					ds.find(Student.class).filter("no", no),
					ds.createUpdateOperations(Student.class)
							.set("teacher", teacher).set("issue", secondChoice));
		}else if((teacher=IssueDAO.selectSubject(thirdChoice))!=null){
			ds.update(
					ds.find(Student.class).filter("no", no),
					ds.createUpdateOperations(Student.class)
							.set("teacher", teacher).set("issue", thirdChoice));
		}
		return true;
	} catch (Exception e) {
		e.printStackTrace();
		return false;
	}
}
 

import org.mongodb.morphia.Datastore; //導入方法依賴的package包/類
public static void main(final String[] args) throws UnknownHostException {
    final Morphia morphia = new Morphia();

    // tell morphia where to find your classes
    // can be called multiple times with different packages or classes
    morphia.mapPackage("org.mongodb.morphia.example");

    // create the Datastore connecting to the database running on the default port on the local host
    final Datastore datastore = morphia.createDatastore(new MongoClient(), "morphia_example");
    datastore.getDB().dropDatabase();
    datastore.ensureIndexes();

    final Employee elmer = new Employee("Elmer Fudd", 50000.0);
    datastore.save(elmer);

    final Employee daffy = new Employee("Daffy Duck", 40000.0);
    datastore.save(daffy);

    final Employee pepe = new Employee("Pepé Le Pew", 25000.0);
    datastore.save(pepe);

    elmer.getDirectReports().add(daffy);
    elmer.getDirectReports().add(pepe);

    datastore.save(elmer);

    Query<Employee> query = datastore.find(Employee.class);
    final List<Employee> employees = query.asList();

    Assert.assertEquals(3, employees.size());

    List<Employee> underpaid = datastore.find(Employee.class)
                                        .filter("salary <=", 30000)
                                        .asList();
    Assert.assertEquals(1, underpaid.size());

    underpaid = datastore.find(Employee.class)
                         .field("salary").lessThanOrEq(30000)
                         .asList();
    Assert.assertEquals(1, underpaid.size());

    final Query<Employee> underPaidQuery = datastore.find(Employee.class)
                                                    .filter("salary <=", 30000);
    final UpdateOperations<Employee> updateOperations = datastore.createUpdateOperations(Employee.class)
                                                                 .inc("salary", 10000);

    final UpdateResults results = datastore.update(underPaidQuery, updateOperations);

    Assert.assertEquals(1, results.getUpdatedCount());

    final Query<Employee> overPaidQuery = datastore.find(Employee.class)
                                                   .filter("salary >", 100000);
    datastore.delete(overPaidQuery);
}
 

import org.mongodb.morphia.Datastore; //導入方法依賴的package包/類
@Test
public final void testEmbeddedClassname() {
    Datastore ds = getDs();

    Root r = new Root();
    r.singleA = new A();
    ds.save(r);

    ds.update(ds.find(Root.class), ds.createUpdateOperations(Root.class).addToSet("aList", new A()));
    r = ds.get(Root.class, "id");
    DBObject aRaw = r.singleA.raw;

    // Test that singleA does not contain the class name
    Assert.assertFalse(aRaw.containsField(Mapper.CLASS_NAME_FIELDNAME));

    // Test that aList does not contain the class name
    aRaw = r.aList.get(0).raw;
    Assert.assertFalse(aRaw.containsField(Mapper.CLASS_NAME_FIELDNAME));

    // Test that bList does not contain the class name of the subclass
    ds.update(ds.find(Root.class), ds.createUpdateOperations(Root.class).addToSet("bList", new B()));
    r = ds.get(Root.class, "id");

    aRaw = r.aList.get(0).raw;
    Assert.assertFalse(aRaw.containsField(Mapper.CLASS_NAME_FIELDNAME));

    DBObject bRaw = r.bList.get(0).getRaw();
    Assert.assertFalse(bRaw.containsField(Mapper.CLASS_NAME_FIELDNAME));

    ds.delete(ds.find(Root.class));

    //test saving an B in aList, and it should have the classname.
    Root entity = new Root();
    entity.singleA = new B();
    ds.save(entity);
    ds.update(ds.find(Root.class), ds.createUpdateOperations(Root.class).addToSet("aList", new B()));
    r = ds.get(Root.class, "id");

    // test that singleA.raw *does* contain the classname because we stored a subclass there
    aRaw = r.singleA.raw;
    Assert.assertTrue(aRaw.containsField(Mapper.CLASS_NAME_FIELDNAME));
    DBObject bRaw2 = r.aList.get(0).raw;
    Assert.assertTrue(bRaw2.containsField(Mapper.CLASS_NAME_FIELDNAME));
}