Abfrage nach Dokumenten, bei denen die Arraygröße größer als 1 ist

Ich habe eine MongoDB-Sammlung mit Dokumenten im folgenden Format:

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

Ich kann derzeit Dokumente abrufen, die einer bestimmten Arraygröße entsprechen:

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

Dadurch werden die Dokumente mit 2 Elementen im nameArray korrekt zurückgegeben . Ich kann jedoch keinen $gtBefehl ausführen, um alle Dokumente zurückzugeben, bei denen das nameFeld eine Arraygröße von mehr als 2 hat:

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

Wie kann ich alle Dokumente mit einem nameArray mit einer Größe größer als eins auswählen (vorzugsweise ohne die aktuelle Datenstruktur ändern zu müssen)?

Aktualisieren:

Für Mongodb-Versionen 2.2+ ist dies eine effizientere Methode, die von @JohnnyHK in einer anderen Antwort beschrieben wird .

1.Mit $ where

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

Aber...

Javascript wird langsamer ausgeführt als die auf dieser Seite aufgeführten nativen Operatoren, ist jedoch sehr flexibel. Weitere Informationen finden Sie auf der serverseitigen Verarbeitungsseite.

2.Erstellen Sie ein zusätzliches Feld NamesArrayLength, aktualisieren Sie es mit der Länge des Namensarrays und verwenden Sie es dann in Abfragen:

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

Es ist eine bessere Lösung und funktioniert viel schneller (Sie können einen Index dafür erstellen).

In MongoDB 2.2+ gibt es jetzt eine effizientere Möglichkeit, numerische Array-Indizes in Abfrageobjektschlüsseln zu verwenden.

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

Sie können diese Abfrage mit einem Index unterstützen, der einen Teilfilterausdruck verwendet (erfordert 3.2+):

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

Ich glaube, dies ist die schnellste Abfrage, die Ihre Frage beantwortet, da keine interpretierte $whereKlausel verwendet wird:

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

Es bedeutet "alle Dokumente außer denen ohne Namen (entweder nicht vorhanden oder leeres Array) oder mit nur einem Namen."

Prüfung:

> 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" ] }
>

Sie können auch Aggregat verwenden:

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

// Sie fügen dem Transitdokument "size_of_name" hinzu und filtern damit die Größe des Namens

Versuchen Sie so etwas zu tun:

db.getCollection('collectionName').find({'ArrayName.1': {$exists: true}})

1 ist die Nummer. Wenn Sie einen Datensatz größer als 50 abrufen möchten, führen Sie ArrayName.50 aus. Danke.

Keines der oben genannten hat bei mir funktioniert. Dieser hat es getan, also teile ich es:

db.collection.find( {arrayName : {$exists:true}, $where:'this.arrayName.length>1'} )

Sie können verwenden $ expr (3.6 Mongo-Versionsoperator) verwenden, um Aggregationsfunktionen in regulären Abfragen zu verwenden.

Vergleichen query operatorsvs aggregation comparison operators.

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

db.accommodations.find({"name":{"$exists":true, "$ne":[], "$not":{"$size":1}}})

MongoDB 3.6 enthält $ expr https://docs.mongodb.com/manual/reference/operator/query/expr/

Sie können $ expr verwenden, um einen Ausdruck innerhalb einer $ match auszuwerten oder zu finden.

{ $match: {
           $expr: {$gt: [{$size: "$yourArrayField"}, 0]}
         }
}

oder finden

collection.find({$expr: {$gte: [{$size: "$yourArrayField"}, 0]}});

Ich habe diese Lösung gefunden, um Elemente mit einem Array-Feld zu finden, das größer als eine bestimmte Länge ist

db.allusers.aggregate([
  {$match:{username:{$exists:true}}},
  {$project: { count: { $size:"$locations.lat" }}},
  {$match:{count:{$gt:20}}}
])

Das erste $ match-Aggregat verwendet ein Argument, das für alle Dokumente gilt. Wenn leer, würde ich bekommen

"errmsg" : "exception: The argument to $size must be an Array, but was of type: EOO"

Ich kenne die alte Frage, aber ich versuche dies mit $ gte und $ size in find. Ich denke zu finden () ist schneller.

db.getCollection('collectionName').find({ name : { $gte : {  $size : 1 } }})

Obwohl die obigen Antworten alle funktionieren, war das, was Sie ursprünglich versucht haben, der richtige Weg, aber Sie haben nur die Syntax rückwärts (wechseln Sie "$ size" und "$ gt").

Richtig:

db.collection.find({items: {$gt: {$size: 1}}})

Falsch:

db.collection.find({items: {$size: {$gt: 1}}})