@Override public void prePersist(final Object entity, final DBObject dbObj, final Mapper mapper) { MappedClass mclass = mapper.getMappedClass(entity); Field id = mclass.getIdField(); if (id != null && id.getAnnotation(GeneratedValue.class) != null) { try { id.setAccessible(true); final String collName = gen.value(mclass.getClazz()); final Query<StoredId> q = db.find(StoredId.class, "_id", collName); final UpdateOperations<StoredId> uOps = db.createUpdateOperations(StoredId.class) .inc("value"); StoredId newId = db.findAndModify(q, uOps); if (newId == null) { newId = new StoredId(collName); db.save(newId); } id.set(entity, newId.value); } catch (Exception ex) { throw new IllegalStateException("Can't generate ID on " + mclass, ex); } } }
private UpdateOperations<JobPo> addUpdateField(UpdateOperations<JobPo> operations, String field, Object o) { if (!checkCondition(o)) { return operations; } operations.set(field, o); return operations; }
@Override public void save(CollectionItemData data) { Query<CollectionItemData> query = createQuery(data.getCollectionId()) .field(ITEM).equal(data.getItem()); UpdateOperations<CollectionItemData> updateOperations = datastore.createUpdateOperations( CollectionItemData.class); Optional<FormData> formData = data.getFormData(); if (formData.isPresent()) { updateOperations.set(FORM_DATA, formData.get()); } else { updateOperations.unset(FORM_DATA); } datastore.update(query, updateOperations, new UpdateOptions().upsert(true)); }
@Override public <T> UpdateResults update(final Query<T> query, final UpdateOperations<T> operations, final UpdateOptions options) { DBCollection dbColl = query.getCollection(); // TODO remove this after testing. if (dbColl == null) { dbColl = getCollection(query.getEntityClass()); } final MappedClass mc = getMapper().getMappedClass(query.getEntityClass()); final List<MappedField> fields = mc.getFieldsAnnotatedWith(Version.class); DBObject queryObject = query.getQueryObject(); if (operations.isIsolated()) { queryObject.put("$isolated", true); } if (!fields.isEmpty()) { operations.inc(fields.get(0).getNameToStore(), 1); } final BasicDBObject update = (BasicDBObject) ((UpdateOpsImpl) operations).getOps(); if (LOG.isTraceEnabled()) { LOG.trace(format("Executing update(%s) for query: %s, ops: %s, multi: %s, upsert: %s", dbColl.getName(), queryObject, update, options.isMulti(), options.isUpsert())); } return new UpdateResults(dbColl.update(queryObject, update, enforceWriteConcern(options, query.getEntityClass()) .getOptions())); }
@Override public void addTag(@Nonnull OWLEntity entity, @Nonnull TagId tagId) { try { writeLock.lock(); Query<EntityTags> query = tagWithProjectIdAndEntity(projectId, entity); UpdateOperations<EntityTags> updateOps = datastore.createUpdateOperations(EntityTags.class); updateOps.addToSet(TAGS, tagId); datastore.update(query, updateOps); } finally { writeLock.unlock(); } }
public void updatePush(String jobId, String var, String value) { Query<LGJob> query = createQuery().field("_id").equal(jobId); UpdateOperations<LGJob> ops = getDatastore().createUpdateOperations(LGJob.class).add(var, value); getDatastore().update(query, ops); }
@Override public void addApiKey(@Nonnull UserId userId, @Nonnull ApiKeyRecord record) { UserApiKeys existingKeys = datastore.createQuery(UserApiKeys.class) .field(USER_ID).equal(userId) .get(); if (existingKeys == null) { datastore.save(new UserApiKeys(userId, singletonList(record))); } else { Optional<ApiKeyRecord> existingKeyRecord = existingKeys.getApiKeys().stream() .filter(r -> r.getApiKeyId().equals(record.getApiKeyId())) .findFirst(); existingKeyRecord.ifPresent(existing -> dropApiKey(userId, existing.getApiKeyId())); UpdateOperations<UserApiKeys> updateOps = datastore.createUpdateOperations(UserApiKeys.class) .addToSet(API_KEYS, record); datastore.update(existingKeys, updateOps); } }
private UpdateOperations<JobPo> addUpdateField(UpdateOperations<JobPo> operations, String field, Object o) { if (!checkCondition(o)) { return operations; } operations.set(field, o); return operations; }
private <T> void updateForVersioning(final Query<T> query, final UpdateOperations<T> operations) { final MappedClass mc = mapper.getMappedClass(query.getEntityClass()); if (!mc.getFieldsAnnotatedWith(Version.class).isEmpty()) { operations.inc(mc.getMappedVersionField().getNameToStore()); } }
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 void prePersist(final Object entity, final DBObject dbObj, final Mapper mapper) { MappedClass mclass = mapper.getMappedClass(entity); Field id = mclass.getIdField(); if (id != null && id.getAnnotation(GeneratedValue.class) != null) { try { id.setAccessible(true); final String collName = gen.value(mclass.getClazz()); final Query<StoredId> q = db.find(StoredId.class, "_id", collName); final UpdateOperations<StoredId> uOps = db.createUpdateOperations(StoredId.class) .inc("value"); StoredId newId = db.findAndModify(q, uOps); if (newId == null) { newId = new StoredId(collName); db.save(newId); } id.set(entity, newId.value); } catch (Exception ex) { throw new IllegalStateException("Can't generate ID on " + mclass, ex); } } }
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); }
public long nextRevision() { return (Long) ds .findAndModify( ds.createQuery(MetadataEntity.class).field("name").equal(NAME), ds.createUpdateOperations(MetadataEntity.class).inc("value") ).value; }
@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; }
/** * Returns the next number in the sequence specified . If sequence does not exists * then it will be created * @param name the sequence name * @return the next number in the sequence */ public long next(String name) { UpdateOperations<Sequence> op = ds.createUpdateOperations(Sequence.class); op.inc("number"); Query<Sequence> q = ds.createQuery(Sequence.class).field("_id").equal(name); Sequence seq = ds.findAndModify(q, op, false, true); return seq.number; }
@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; }
public static Seq next(String name) { Datastore ds = MorphiaPlugin.ds(); Query<Seq> q = ds.find(Seq.class, "_id", name); UpdateOperations<Seq> o = ds.createUpdateOperations(Seq.class).inc("value"); Seq newId = ds.findAndModify(q, o); if (null == newId) { newId = new Seq(name); ds.save(newId); } return newId; }
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; }
public int assignNextBuildNumber(final DynamicProject project) { final Datastore datastore = getDatastore(); BuildNumberCounter seq = datastore.findAndModify( datastore.find(BuildNumberCounter.class, "key = ", project.getFullName()), // query datastore.createUpdateOperations(BuildNumberCounter.class).inc("counter") // update ); if (seq == null) { seq = new BuildNumberCounter(project.getFullName(), 1); datastore.save(seq); } return seq.getCounter(); }
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; }