Recherche de documents dont la taille du tableau est supérieure à 1

Question

Je dispose d'une collection MongoDB contenant des documents au format suivant :

{
  "_id" : ObjectId("4e8ae86d08101908e1000001"),
  "name" : ["Name"],
  "zipcode" : ["2223"]
}
{
  "_id" : ObjectId("4e8ae86d08101908e1000002"),
  "name" : ["Another ", "Name"],
  "zipcode" : ["2224"]
}

Je peux actuellement obtenir des documents qui correspondent à une taille de tableau spécifique :

db.accommodations.find({ name : { $size : 2 }})

Cela renvoie correctement les documents avec 2 éléments dans le fichier name réseau. Cependant, je ne peux pas faire un $gt pour retourner tous les documents dans lesquels le name a une taille de tableau supérieure à 2 :

db.accommodations.find({ name : { $size: { $gt : 1 } }})

Comment puis-je sélectionner tous les documents avec un name d'une taille supérieure à un (de préférence sans avoir à modifier la structure de données actuelle) ?

Answer 1

Il existe un moyen plus efficace de le faire dans MongoDB 2.2+ maintenant que vous pouvez utiliser des index de tableaux numériques (basés sur 0) dans les clés des objets de requête.

// Find all docs that have at least two name array elements.
db.accommodations.find({'name.1': {$exists: true}})

Vous pouvez prendre en charge cette requête avec un index qui utilise une expression de filtre partiel (nécessite 3.2+) :

// index for at least two name array elements
db.accommodations.createIndex(
    {'name.1': 1},
    {partialFilterExpression: {'name.1': {$exists: true}}}
);

Answer 2

Mise à jour :

Pour les versions de mongodb 2.2+ Une façon plus efficace de le faire est décrite par @JohnnyHK dans un autre réponse .

---

1.Utilisation où

db.accommodations.find( { $where: "this.name.length > 1" } );

Mais...

Javascript s'exécute plus lentement que les opérateurs natifs listés sur cette page, mais il est très souple. Voir la page sur le traitement côté serveur pour plus d'informations.

2.Créer extra champ NamesArrayLength et le mettre à jour avec la longueur du tableau des noms, puis l'utiliser dans les requêtes :

db.accommodations.find({"NamesArrayLength": {$gt: 1} });

Ce sera une meilleure solution, et fonctionnera beaucoup plus rapidement (vous pouvez créer un index dessus).

Answer 3

Je pense que c'est la requête la plus rapide qui répond à votre question, car elle n'utilise pas de fichier interprété. $where clause :

{$nor: [
    {name: {$exists: false}},
    {name: {$size: 0}},
    {name: {$size: 1}}
]}

Cela signifie "tous les documents sauf ceux qui n'ont pas de nom (soit inexistants, soit vides) ou qui n'ont qu'un seul nom".

Test :

> db.test.save({})
> db.test.save({name: []})
> db.test.save({name: ['George']})
> db.test.save({name: ['George', 'Raymond']})
> db.test.save({name: ['George', 'Raymond', 'Richard']})
> db.test.save({name: ['George', 'Raymond', 'Richard', 'Martin']})
> db.test.find({$nor: [{name: {$exists: false}}, {name: {$size: 0}}, {name: {$size: 1}}]})
{ "_id" : ObjectId("511907e3fb13145a3d2e225b"), "name" : [ "George", "Raymond" ] }
{ "_id" : ObjectId("511907e3fb13145a3d2e225c"), "name" : [ "George", "Raymond", "Richard" ] }
{ "_id" : ObjectId("511907e3fb13145a3d2e225d"), "name" : [ "George", "Raymond", "Richard", "Martin" ] }
>

Answer 4

Vous pouvez également utiliser l'agrégat :

db.accommodations.aggregate(
[
     {$project: {_id:1, name:1, zipcode:1, 
                 size_of_name: {$size: "$name"}
                }
     },
     {$match: {"size_of_name": {$gt: 1}}}
])

// vous ajoutez "size_of_name" au document de transit et l'utilisez pour filtrer la taille du nom.

Answer 5

Vous pouvez utiliser $expr ( 3.6 mongo version operator ) pour utiliser les fonctions d'agrégation dans les requêtes régulières.

Comparez query operators vs aggregation comparison operators .

db.accommodations.find({$expr:{$gt:[{$size:"$name"}, 1]}})