Comment puis-je mettre à jour des documents de mongo db à l'aide du pilote java?

Références:

http://www.mongodb.org/display/DOCS/Java+Tutoriel

Encore assez nouveau pour mongo db, mais je vais essayer de mettre à jour une partie d'un document existant à l'intérieur d'une collection... malheureusement, le lien ci-dessus n'ont pas une mise à jour exemple.

Essentiellement, je veux juste être en mesure de:

Ajouter de nouveaux champs à un document
Mettre à jour les champs d'un document
une nouvelle valeur

Voici mon code (Grain + Groovy + Java + MongoDB + le pilote java):

def shape = mongo.shapes.findOne(new BasicDBObject("data", "http://www.foo.com")); //get the document
mongo.shapes.update(new BasicDBObject("_id", shape._id), new BasicDBObject("isProcessed", 0));  //add a new "isProcessed" field set to 0
mongo.shapes.update(new BasicDBObject("_id", shape._id), new BasicDBObject("data", "http://www.bar.com"));

Ce joli beaucoup clobbers l'ensemble de l'objet... je pourrais essayer seulement la modification de la forme d'origine de l'objet, puis en exécutant la mise à jour sur qui. Mais jusqu'alors, quelqu'un a une expérience de la mise à jour juste champs individuels (plutôt que la totalité du document)?

EDIT:

Je l'ai juste essayé et a réussi à mettre à jour par l'envoi de la totalité de l'objet à travers avec les nouvelles et/ou mis à jour les champs et qui fonctionne. Je me demande si le pilote est assez intelligent pour ne mettre à jour le plus petit sous-ensemble de change ou si c'est juste aveuglément la mise à jour de l'ensemble de la chose? (Dans le cas ci-dessous, c'est juste de la mise à jour de la foo terrain à l'autre bout du fil ou de toute forme de document?)

Code:

def shape = mongo.shapes.findOne(); //get the first shape to use as a base
shape.removeField("_id");  //remove the id field
shape.put("foo","bar");  //add a new field "foo"
mongo.shapes.insert(shape);  //insert the new shape
def shape2 = mongo.shapes.findOne(new BasicDBObject("foo", "bar"));  //get the newly inserted shape (and more importantly, it's id)
shape2.put("foo", "bat");  //update the "foo" field to a new value
mongo.shapes.update(new BasicDBObject("_id", shape2._id), shape2);  //update the existing document in mongo

InformationsquelleAutor longda | 2010-08-27

12

Je me demande si le pilote est assez intelligent pour ne mettre à jour le plus petit sous-ensemble de change ou si c'est juste aveuglément la mise à jour de l'ensemble de la chose?

Non, si vous utilisez la "normale" méthode de mise à jour, l'ensemble de l'objet sera envoyé sur le fil.
Je soupçonne que le serveur de base de données elle-même sera assez intelligent pour ne mettre à jour l'index (et non pas ceux qui n'ont pas changé), si possible (c'est à dire, l'objet pourrait être mis en place et n'ont pas à être déplacé, car il a grandi trop)

Ce que vous pouvez faire est d'utiliser le "atomic mise à jour le modificateur" des fonctions. La documentation de Java est un peu de lumière sur eux, mais puisque le pilote transmet le JSON, l'étoffe de la non-Java tutoriels devrait fonctionner, par exemple:
```
shapes.update((DBObject)JSON.parse(    "{ 'foo' : 'bar'}"),  
    (DBObject) JSON.parse(          "{ '$set' : { 'foo': 'bat'}}")   );
```
- Merci! Je crois que j'aime ce code un peu mieux, c'est légèrement plus claire que la syntaxe standard... je vais l'essayer.
- J'ai essayé cela et ne pouvions pas le faire analyser. Il n'aimait pas les guillemets simples, puis la deuxième JSON.analyse ne peut pas être converti en DBObject (c'est une table de hachage).
- Désolé, le code non testé. Mais il devrait être très similaire à ce qui précède.
InformationsquelleAutor Thilo
11

Trouvé un exemple ici, ce qui semble montrer l'utilisation de l'appel de mise à jour. Donc pour ton exemple, je crois que quelque chose comme cela devrait fonctionner?
```
//Find an object
def shape2 = mongo.shapes.findOne( new BasicDBObject( 'foo', 'bar' ) )
//And update the foo field from 'bar' to 'bat'
mongo.shapes.update( shape2, new BasicDBObject( '$set', new BasicDBObject( 'foo', 'bat' ) ) )
```
Modifier

Vous pourriez être en mesure d'utiliser une catégorie de construire votre BasicDBObjects plus groovy de la sorte...

Quelque chose comme cela pourrait le faire:
```
class BasicDBObjectMapBuilder {
  static String toDbObj( String s ) { s }
  static BasicDBObject toDbObj( Map m ) {
    m.inject( null ) { r, it -> new BasicDBObject( it.key, it.value.toDbObj() ) }
  }
}

use( BasicDBObjectMapBuilder ) {
  def shape2 = mongo.shapes.findOne( new BasicDBObject( 'foo', 'bar' ) )
  //And update the foo field from 'bar' to 'bat'
  mongo.shapes.update( shape2, [ '$set':[ 'foo', 'bat' ] ].toDbObj() )
}
```
Je n'ai pas testé ce que...

Edit 2

En fait, BasicDBObject est la Carte, de sorte que vous devriez être en mesure de le faire:
```
  mongo.shapes.update( shape2, [ '$set':[ 'foo', 'bat' ] ] as BasicDBObject )
```
sans avoir besoin de l'constructeur
- MES YEUX! ILS BRÛLENT! Merci beaucoup pour ce, qui est tout à fait sens aujourd'hui... le code qu'ils font de nous écrire pour ce est SI laid, si! 🙂
- hahaha...oui... je l'ai mis une grossière tentative d'une catégorie de construire la DBObjects en place à partir d'une carte dans un edit...pas testé tho...
- Ouais, Java permet de travailler avec JSON laid. Le pilote Java doit fournir des moyens pour transmettre chaînes JSON (mais qui est également entravée par le manque de multi-ligne de cordes et autre devis caractères en Java), et aussi quelques générateur de méthodes avec des noms significatifs (si vous n'avez pas à taper $set).
InformationsquelleAutor tim_yates
5

Un grand nombre de réponses sur ce post utilisent des versions antérieures de la Mongo Pilote Java. Si vous utilisez une version plus récente du Pilote Java (v3.0+), puis la méthode préférée semble être d'utiliser l'objet Document au lieu de le DBObject interface.

Voici un exemple:
```
MongoClient client = new MongoClient();
MongoCollection<Document> fooCollection = client.getDatabase("test").getCollection("foo");

Bson filter = Filters.eq("_id", "123d45678c467bb433c99f99");
Bson updates = Updates.set("isFoo", true);
fooCollection.findOneAndUpdate(filter, updates);
```
- J'ai essayé votre approche, mais il ne fonctionne pas pour MongoDB Pilote Java 3.2.
InformationsquelleAutor robjwilkins
3

Cette réponse utilise le shell mongo, mais montre comment vous pouvez aller en profondeur dans un objet JSON structure pour modifier un champ spécifique sans écraser le reste.

Compte tenu de l'objet JSON dans une collection appelée "my_collection':
```
{ 
  "_id" : ObjectId("50fdb2a73f7bc7a5acecc4f8"), 
  "data" : { 
    "list" : [ 0, 1, 2, 7, 4, 5 ], 
    "subobj" : { 
       "var_a":"valuea",
       "var_b":"valueb" 
     }
  }
}
```
À la mise à jour "var_b' , sans écraser d'autre chose:
```
db.my_collection.update({"_id":"50fdb2a73f7bc7a5acecc4f8"}, { "$set":{"data.subobj.var_b":"new_value"}})
```
Pour mettre à jour le 3ème élément du tableau 'liste' avec la valeur '99', sans écraser d'autre chose:
```
db.my_collection.update({"_id":"50fdb2a73f7bc7a5acecc4f8"}, { "$set":{"data.list.2":"99"} } )
```
InformationsquelleAutor ElStepherino

DBCollection dbCollection = db.getCollection("mycollection");
BasicDBObject dbObject = new BasicDBObject();
dbObject.put("_id", "3"); 
//your update condition - or the query
DBObject newObject =  dbCollection.find(dbObject).toArray().get(0);
//I just take the first element. Can iterate through as per your requirement if multiple fields        exist
newObject.put("key","value");
//add field, either a new field or any existing field
dbCollection.findAndModify(dbObject, newObject);

Utilisez simplement les étapes ci-dessus . Vous pouvez modifier les données sans affecter d'autres éléments associés à la même clé.

InformationsquelleAutor Arun A K

//mise à jour

WriteResult usr = (WriteResult)mongoOperation.upsert(new  Query(Criteria.where("name").is("till")),  

Update.update("password", "jk45"), "collection");

System.out.println("updatedUser : " + usr );

InformationsquelleAutor user2164052

Vous devez vous connecter pour publier un commentaire.

Modifier

Edit 2