org.mongodb.morphia.query.UpdateOperations Java Examples

private UpdateOperations<JobPo> buildUpdateOperations(JobQueueReq request) {
    UpdateOperations<JobPo> operations = template.createUpdateOperations(JobPo.class);
    addUpdateField(operations, "cronExpression", request.getCronExpression());
    addUpdateField(operations, "needFeedback", request.getNeedFeedback());
    addUpdateField(operations, "extParams", request.getExtParams());
    addUpdateField(operations, "triggerTime", request.getTriggerTime() == null ? null : request.getTriggerTime().getTime());
    addUpdateField(operations, "priority", request.getPriority());
    addUpdateField(operations, "maxRetryTimes", request.getMaxRetryTimes());
    addUpdateField(operations, "relyOnPrevCycle", request.getRelyOnPrevCycle() == null ? true : request.getRelyOnPrevCycle());
    addUpdateField(operations, "submitNodeGroup", request.getSubmitNodeGroup());
    addUpdateField(operations, "taskTrackerNodeGroup", request.getTaskTrackerNodeGroup());
    addUpdateField(operations, "repeatCount", request.getRepeatCount());
    addUpdateField(operations, "repeatInterval", request.getRepeatInterval());
    addUpdateField(operations, "gmtModified", SystemClock.now());
    return operations;
}
 

protected boolean lockJob(String taskTrackerNodeGroup, String jobId, String taskTrackerIdentity, Long triggerTime, Long gmtModified) {
    UpdateOperations<JobPo> operations =
            template.createUpdateOperations(JobPo.class)
                    .set("isRunning", true)
                    .set("taskTrackerIdentity", taskTrackerIdentity)
                    .set("gmtModified", SystemClock.now());

    String tableName = JobQueueUtils.getExecutableQueueName(taskTrackerNodeGroup);

    Query<JobPo> updateQuery = template.createQuery(tableName, JobPo.class);
    updateQuery.field("jobId").equal(jobId)
            .field("isRunning").equal(false)
            .field("triggerTime").equal(triggerTime)
            .field("gmtModified").equal(gmtModified);
    UpdateResults updateResult = template.update(updateQuery, operations);
    return updateResult.getUpdatedCount() == 1;
}
 

@Override
public int incRepeatedCount(String jobId) {
    while (true) {
        JobPo jobPo = getJob(jobId);
        if (jobPo == null) {
            return -1;
        }
        Query<JobPo> query = template.createQuery(JobPo.class);
        query.field("jobId").equal(jobId);
        query.field("repeatedCount").equal(jobPo.getRepeatedCount());

        UpdateOperations<JobPo> opts = template.createUpdateOperations(JobPo.class);
        opts.set("repeatedCount", jobPo.getRepeatedCount() + 1);

        UpdateResults ur = template.update(query, opts);
        if (ur.getUpdatedCount() == 1) {
            return jobPo.getRepeatedCount() + 1;
        }
    }
}
 

/**
 * 增加属性的值
 * 
 * @param num
 *            增加量
 * @param fieldName
 *            属性名称
 * @return
 */
public static HallInfo incFieldNum(int num, String fieldName) {
	Query<HallInfo> query = hallInfoDao.createQuery();
	UpdateOperations<HallInfo> updateOperations = hallInfoDao.createUpdateOperations().inc(fieldName, num);
	HallInfo hallInfo = hallInfoDao.getDs().findAndModify(query, updateOperations);
	if (hallInfo == null) {
		hallInfo = new HallInfo();
		hallInfoDao.save(hallInfo);
		hallInfo = hallInfoDao.getDs().findAndModify(query, updateOperations);
	}
	return hallInfo;
}
 

public void resume(JobPo jobPo) {
    String tableName = JobQueueUtils.getExecutableQueueName(jobPo.getTaskTrackerNodeGroup());
    Query<JobPo> query = template.createQuery(tableName, JobPo.class);

    query.field("jobId").equal(jobPo.getJobId());

    UpdateOperations<JobPo> operations =
            template.createUpdateOperations(JobPo.class)
                    .set("isRunning", false)
                    .set("taskTrackerIdentity", "")
                    .set("gmtModified", SystemClock.now());
    template.update(query, operations);
}
 

@Override
public boolean updateLastGenerateTriggerTime(String jobId, Long lastGenerateTriggerTime) {
    Query<JobPo> query = template.createQuery(getTableName(), JobPo.class);

    query.field("jobId").equal(jobId);

    UpdateOperations<JobPo> operations =
            template.createUpdateOperations(JobPo.class)
                    .set("lastGenerateTriggerTime", lastGenerateTriggerTime)
                    .set("gmtModified", SystemClock.now());

    UpdateResults ur = template.update(query, operations);
    return ur.getUpdatedCount() == 1;
}
 

private UpdateOperations<JobPo> addUpdateField(UpdateOperations<JobPo> operations, String field, Object o) {
    if (!checkCondition(o)) {
        return operations;
    }
    operations.set(field, o);
    return operations;
}
 

@Override
public boolean selectiveUpdateByTaskId(JobQueueReq request) {
    Assert.hasLength(request.getRealTaskId(), "Only allow update by realTaskId and taskTrackerNodeGroup");
    Assert.hasLength(request.getTaskTrackerNodeGroup(), "Only allow update by realTaskId and taskTrackerNodeGroup");

    Query<JobPo> query = template.createQuery(getTargetTable(request.getTaskTrackerNodeGroup()), JobPo.class);
    query.field("realTaskId").equal(request.getRealTaskId());
    query.field("taskTrackerNodeGroup").equal(request.getTaskTrackerNodeGroup());

    UpdateOperations<JobPo> operations = buildUpdateOperations(request);
    UpdateResults ur = template.update(query, operations);
    return ur.getUpdatedCount() == 1;
}
 

@Override
public boolean selectiveUpdateByJobId(JobQueueReq request) {
    Assert.hasLength(request.getJobId(), "Only allow update by jobId");

    Query<JobPo> query = template.createQuery(getTargetTable(request.getTaskTrackerNodeGroup()), JobPo.class);
    query.field("jobId").equal(request.getJobId());

    UpdateOperations<JobPo> operations = buildUpdateOperations(request);
    UpdateResults ur = template.update(query, operations);
    return ur.getUpdatedCount() == 1;
}
 

public <T> UpdateOperations<T> createUpdateOperations(final Class<T> clazz) {
    return ds.createUpdateOperations(clazz);
}
 

public <T> T findAndModify(final Query<T> query, final UpdateOperations<T> ops) {
    return findAndModify(query, ops, false);
}
 

public <T> T findAndModify(final Query<T> query, final UpdateOperations<T> ops, final boolean oldVersion) {
    return findAndModify(query, ops, oldVersion, false);
}
 

public <T> T findAndModify(final Query<T> query, final UpdateOperations<T> ops, final boolean oldVersion, final boolean createIfMissing) {
    return ds.findAndModify(query, ops, oldVersion, createIfMissing);
}
 

public <T> UpdateResults update(final Query<T> query, final UpdateOperations<T> ops, final boolean createIfMissing) {
    return ds.update(query, ops, createIfMissing);
}
 

public <T> UpdateResults update(final Query<T> query, final UpdateOperations<T> ops) {
    return ds.update(query, ops);
}
 

public <T> UpdateResults updateFirst(final Query<T> query, final UpdateOperations<T> ops, final boolean createIfMissing) {
    return ds.updateFirst(query, ops, createIfMissing);
}
 

public <T> UpdateResults updateFirst(final Query<T> query, final UpdateOperations<T> ops) {
    return ds.updateFirst(query, ops);
}
 

/**
 * 改变邮件状态
 * 
 * @author JiangZhiYong
 * @QQ 359135103 2017年9月21日 下午4:15:10
 * @param id
 * @param mailState
 */
public static Mail modifyMailState(long id, int mailState) {
	Query<Mail> query = mailDao.createQuery().filter("id", id);
	UpdateOperations<Mail> operations = mailDao.createUpdateOperations().set("state", mailState);
	return mailDao.getDs().findAndModify(query, operations);
}