@SuppressWarnings("unchecked") private <T> MongoCollection<T> getMongoCollection(final String name, final Class<T> clazz, final WriteConcern concern) { final MongoCollection<T> collection = database.getCollection(name, clazz); return enforceWriteConcern(collection, clazz, concern); }
protected <T> Key<T> insert(final DBCollection dbColl, final T entity, final InsertOptions options) { final LinkedHashMap<Object, DBObject> involvedObjects = new LinkedHashMap<Object, DBObject>(); dbColl.insert(singletonList(entityToDBObj(entity, involvedObjects)), enforceWriteConcern(options, entity.getClass()) .getOptions()); return postSaveOperations(singletonList(entity), involvedObjects, dbColl.getName()).get(0); }
private <T> Iterable<Key<T>> insert(final DBCollection dbColl, final Iterable<T> entities, final InsertOptions options) { if (!entities.iterator().hasNext()) { return emptyList(); } final Map<Object, DBObject> involvedObjects = new LinkedHashMap<Object, DBObject>(); final List<DBObject> list = new ArrayList<DBObject>(); com.mongodb.InsertOptions insertOptions = options.getOptions(); for (final T entity : entities) { if (options.getWriteConcern() == null) { insertOptions = enforceWriteConcern(options, entity.getClass()).getOptions(); } list.add(toDbObject(entity, involvedObjects)); } dbColl.insert(list, insertOptions); return postSaveOperations(entities, involvedObjects, dbColl.getName()); } /*
@Override public <T> Key<T> save(final T entity, final InsertOptions options) { if (entity == null) { throw new UpdateException("Can not persist a null entity"); } final T unwrapped = ProxyHelper.unwrap(entity); return save(getCollection(unwrapped), unwrapped, enforceWriteConcern(options, entity.getClass())); }
protected <T> Key<T> save(final DBCollection dbColl, final T entity, final InsertOptions options) { final MappedClass mc = validateSave(entity); // involvedObjects is used not only as a cache but also as a list of what needs to be called for life-cycle methods at the end. final LinkedHashMap<Object, DBObject> involvedObjects = new LinkedHashMap<Object, DBObject>(); final DBObject document = entityToDBObj(entity, involvedObjects); // try to do an update if there is a @Version field final Object idValue = document.get("_id"); WriteResult wr = tryVersionedUpdate(dbColl, entity, document, idValue, enforceWriteConcern(options, entity.getClass()), mc); if (wr == null) { saveDocument(dbColl, document, options); } return postSaveOperations(singletonList(entity), involvedObjects, dbColl.getName()).get(0); }
@SuppressWarnings("deprecation") private void ensureEntityWriteConcern() { DatastoreImpl datastore = (DatastoreImpl) getAds(); assertEquals(ACKNOWLEDGED, datastore.enforceWriteConcern(new InsertOptions(), Simple.class) .getWriteConcern()); assertEquals(ACKNOWLEDGED, datastore.enforceWriteConcern(new UpdateOptions(), Simple.class) .getWriteConcern()); assertEquals(ACKNOWLEDGED, datastore.enforceWriteConcern(new FindAndModifyOptions(), Simple.class) .getWriteConcern()); }
@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 <T> WriteResult delete(final Query<T> query, final DeleteOptions options) { DBCollection dbColl = query.getCollection(); // TODO remove this after testing. if (dbColl == null) { dbColl = getCollection(query.getEntityClass()); } if (query.getSortObject() != null || query.getOffset() != 0 || query.getLimit() > 0) { throw new QueryException("Delete does not allow sort/offset/limit query options."); } return dbColl.remove(query.getQueryObject(), enforceWriteConcern(options, query.getEntityClass()).getOptions()); }
enforceWriteConcern(options, query.getEntityClass()) .getOptions()));
@Override public <T> T findAndDelete(final Query<T> query, final FindAndModifyOptions options) { DBCollection dbColl = query.getCollection(); if (dbColl == null) { dbColl = getCollection(query.getEntityClass()); } if (LOG.isTraceEnabled()) { LOG.trace("Executing findAndModify(" + dbColl.getName() + ") with delete ..."); } FindAndModifyOptions copy = enforceWriteConcern(options, query.getEntityClass()) .copy() .projection(query.getFieldsObject()) .sort(query.getSortObject()) .returnNew(false) .upsert(false) .remove(true); final DBObject result = dbColl.findAndModify(query.getQueryObject(), copy.getOptions()); return result == null ? null : mapper.fromDBObject(this, query.getEntityClass(), result, createCache()); }
@Test @SuppressWarnings("deprecation") public void testEnforceWriteConcern() { DatastoreImpl ds = (DatastoreImpl) getDs(); FindAndModifyOptions findAndModifyOptions = new FindAndModifyOptions(); assertNull(findAndModifyOptions.getWriteConcern()); assertEquals(ACKNOWLEDGED, ds.enforceWriteConcern(findAndModifyOptions, FacebookUser.class) .getWriteConcern()); assertEquals(MAJORITY, ds.enforceWriteConcern(findAndModifyOptions.writeConcern(MAJORITY), FacebookUser.class) .getWriteConcern()); InsertOptions insertOptions = new InsertOptions(); assertNull(insertOptions.getWriteConcern()); assertEquals(ACKNOWLEDGED, ds.enforceWriteConcern(insertOptions, FacebookUser.class) .getWriteConcern()); assertEquals(MAJORITY, ds.enforceWriteConcern(insertOptions.writeConcern(MAJORITY), FacebookUser.class) .getWriteConcern()); UpdateOptions updateOptions = new UpdateOptions(); assertNull(updateOptions.getWriteConcern()); assertEquals(ACKNOWLEDGED, ds.enforceWriteConcern(updateOptions, FacebookUser.class) .getWriteConcern()); assertEquals(MAJORITY, ds.enforceWriteConcern(updateOptions.writeConcern(MAJORITY), FacebookUser.class) .getWriteConcern()); DeleteOptions deleteOptions = new DeleteOptions(); assertNull(deleteOptions.getWriteConcern()); assertEquals(ACKNOWLEDGED, ds.enforceWriteConcern(deleteOptions, FacebookUser.class) .getWriteConcern()); assertEquals(MAJORITY, ds.enforceWriteConcern(deleteOptions.writeConcern(MAJORITY), FacebookUser.class) .getWriteConcern()); }