Wie viele Parameter werden in MongoDB maximal an $ in query übergeben?

Wie viele Parameter werden in MongoDB maximal an $ in query übergeben?

Die Abfrage selbst ist ein Dokument . MongoDB begrenzt die Dokumentgröße (ab Version 2.4.0+) auf 16 MB.

Wirklich, was Sie mit einem Fund machen, ist:

db.collectionName.find(queryDoc)

Dabei ist 'queryDoc' so etwas wie:

{ 'fieldOne' : { $in : [ 1, 2, 3, 4] } }

Verwenden Sie den Befehl bsonsize, um die maximale Anzahl von Werten zu ermitteln, die Sie an eine $ in-Abfrage übergeben können :

mongos> Object.bsonsize([1])
16
mongos> Object.bsonsize({ 'fieldOne' : { $in : [ 1, 2, 3, 4] } })
74
mongos> Object.bsonsize({ 'fieldOne' : { $in : [ 1, 2, 3, 4, 5] } })
85
mongos> Object.bsonsize({ 'fieldOne' : { $in : [ 1, 2, 3, 4, 5, 6] } })
96

Sie können also sehen, dass jede zusätzliche Ganzzahl eine Größe von 11 Byte hat. Nicht 11 Bits, 11 BYTES. Dies liegt an der Art und Weise, wie BSON intern Zahlen mit jeweils mindestens 64 Bit plus dem Wrapper speichert. Dies kann leicht gesehen werden mit:

mongos> Object.bsonsize({ 'fieldOne' : { $in : [ 1, 2, 3, 4, 5, 6, 69000] } })
107
mongos> Object.bsonsize({ 'fieldOne' : { $in : [ 1, 2, 3, 4, 5, 6, 6900000] } })
107
mongos> Object.bsonsize({ 'fieldOne' : { $in : [ 1, 2, 3, 4, 5, 6, 69000000000] } })
107
mongos> Object.bsonsize({ 'fieldOne' : { $in : [ 1, 2, 3, 4, 5, 6, 69000000000000] } })
107
mongos> Object.bsonsize({ 'fieldOne' : { $in : [ 1, 2, 3, 4, 5, 6, 6900000000000000] } })
107
mongos> Object.bsonsize({ 'fieldOne' : { $in : [ 1, 2, 3, 4, 5, 6, 690000000000000000] } })
107
mongos> Object.bsonsize({ 'fieldOne' : { $in : [ 1, 2, 3, 4, 5, 6, 69000000000000000000] } })
107
mongos> Object.bsonsize({ 'fieldOne' : { $in : [ 1, 2, 3, 4, 5, 6, 6900000000000000000000] } })
107
mongos> Object.bsonsize({ 'fieldOne' : { $in : [ 1, 2, 3, 4, 5, 6, 69000000000000000000000000] } })
107

Egal wie groß eine einzelne Zahl ist, sie hat dieselbe Größe.

Weiter zur Frage selbst: Wie groß ist das Abfragedokument?

Wenn Sie diese für eine Abfrage mit einem Feld mit einer $ in-Klausel in Pymongo über die mavos-Javascript-Eingabeaufforderung addieren, erhalten Sie alle dieselben Additionsfakten für die maximale Größe einer $ in-Abfrage:

mongos> Object.bsonsize({ 'a' : { '$in' : [1] }})
34
mongos> Object.bsonsize({ '' : { '$in' : [1] }})
33
mongos> Object.bsonsize({ '' : { '$in' : [] }})
22

• Das Abfragedokument selbst ist 22 Byte;
• Jedes Byte des Feldnamens fügt ein einzelnes Byte hinzu.
• Jede der $ in-Klausel hinzugefügte Zahl fügt 11 Bytes hinzu.

Angenommen, Sie haben einen Ein-Byte-Feldnamen (das Minimum, wirklich), dann ist Ihr Maximum:

mongos> 16*1024*1024
16777216
mongos> (16*1024*1024) - 22 - 1 
16777193
mongos> ((16*1024*1024) - 22 -1) / 11
1525199.3636363635

DIE ANTWORT: 1.525.198 (Das sind 1,5 Millionen. Das ist ziemlich groß.)

Es gibt anscheinend keine Einschränkung.

Ich habe einen kleinen Test gemacht.

1) Sammlung A hatte - 1 Million einfaches JSON-Objekt {id :, name:}

2) In Sammlung B habe ich Referenz-IDs von Sammlung A geladen, bis ich die folgende Ausnahme erhalten habe. Ich könnte einen Referenzzähler von 450k von max.

Exception in thread "main" com.mongodb.MongoInternalException: DBObject of size 18388885 is over Max BSON size 16777216

3) Ich könnte 450.000 dieser IDs als $ in [id1 ... id450000] senden und die gesamte Liste der 450.000 IDs aus 1 Million Objekten in Sammlung A abrufen.

Beeindruckend! das ist mehr als genug für meine Bewerbung: D. MongoDB ist wirklich cool.

Ich denke, die Einschränkung wird nur durch die Größe eines BSONDocuments bestimmt. Wenn Sie eine Abfrage definieren, können Sie einer $ in-Klausel so lange Werte hinzufügen, bis Sie die maximale Dokumentgröße überschreiten. Wie viele Werte Sie in der Klausel haben können, hängt davon ab, wie groß jeder Wert ist (je kleiner die Größe jedes Werts ist, desto mehr können Sie in die $ in-Klausel aufnehmen).

In Bezug auf die Leistung gibt es, wie ich festgestellt habe, einen "Sweet Spot" für die Anzahl der Werte in einer $ in-Klausel. Siehe meine Antwort in dieser verwandten Frage: Ist es in Ordnung, eine MongoDB mehrmals pro Anfrage abzufragen?

dh Abwägen der Anzahl der Werte in der $ in-Klausel gegen die Anzahl der gesendeten Abfragen. Ich bin mitten in einem Blog-Beitrag darüber, um zu versuchen, mehr Details zu erfahren.

Ich habe nach einer Antwort gesucht, um zu bestätigen, wie viele UUID ich in einer IN-Klausel übergeben kann. Veröffentlichen Sie das Ergebnis also nur für den Fall, dass es anderen hilft.

Ich habe versucht, 500 UUID wie folgt zu übergeben:

 Object.bsonsize({ 'fieldOne' : { $in : [ 
    "3bd209e1-41c9-4ad2-a62c-bbe3d2ae490a",
    "3bd209e1-41c9-4ad2-a62c-bbe3d2ae490a",
    "3bd209e1-41c9-4ad2-a62c-bbe3d2ae490a".
     ..
     ..] } })

Das Ergebnis war: 23518