¿Cuál es el número máximo de parámetros pasados ​​a $ en la consulta en MongoDB?

Question

¿Cuál es la cantidad máxima de parámetros pasados ​​a $ in query en MongoDB?

Answer 1

Parece que no hay limitación.

Hice una pequeña prueba.

1) Colección Una tenían - 1 Millón sencilla objeto JSON {id:, nombre:}

2) En colección B, cargué los identificadores de referencia de la colección A hasta que llegué la siguiente excepción. Podría insertar un recuento de referencia de 450k de máx.

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

3) Podría enviar a 450k de estos identificadores como $ en [... ID1 id450000] y tirar toda la lista de identificadores de 450K de 1 millón de objetos de colección A.

Wow! esto es más que suficiente para mi aplicación: D. MongoDB es realmente genial.

Answer 2

Creo que la limitación solo está determinada por el tamaño de un BSONDocument. Cuando define una consulta, puede seguir agregando valores en una cláusula $ in hasta que exceda el tamaño máximo del documento. Entonces, cuántos valores puede tener en la cláusula depende de qué tan grande sea cada valor (cuanto menor sea el tamaño de cada valor, más se puede incluir en la cláusula $ in).

En términos de rendimiento, por lo que he encontrado, hay un "punto óptimo" para la cantidad de valores en una cláusula $ in. Ver mi respuesta en esta pregunta relacionada: Is it OK to query a MongoDB multiple times per request?

es decir, equilibrar el número de valores en la cláusula $ in frente al número de consultas enviadas. Estoy en medio de una publicación de blog sobre eso para tratar de profundizar en más detalles.

Answer 3

La consulta en sí es un documento. MongoDB limita el tamaño de los documentos (a partir de la versión 2.4.0+) a 16 MB.

En realidad, lo que está haciendo con un hallazgo es:

db.collectionName.find(queryDoc) 

donde 'queryDoc' es algo así como:

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

para encontrar el número máximo de valores se puede pasar a una $ en la consulta, utilice la bsonsize comando:

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 

por lo tanto, Puedes ver que cada entero adicional tiene un tamaño de 11 bytes. No 11 bits, 11 BYTES. Esto se debe a la forma en que BSON almacena internamente números de al menos 64 bits cada uno, más el contenedor. Esto se puede ver fácilmente con:

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 

tanto, no importa cuál sea el tamaño de un número individual, que es el mismo bsonsize.

En la pregunta en sí: ¿Qué tan grande es ese documento de consulta?

Adición de éstos para una consulta de un campo con un $ en la cláusula, en pymongo, a través de los mongo Javascript rápida, lo que sea, todo yeild las mismas operaciones de suma para el tamaño máximo de un $ en la consulta:

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

• El documento de consulta en sí tiene 22 bytes;
• Cada byte del nombre de campo agrega un solo byte;
• Cada número agregado a la cláusula $ in agrega 11 bytes.

lo tanto, usted Suponiendo que tenga un nombre de campo de un byte (el mínimo, en realidad), su máxima es:

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

LA RESPUESTA: (.. Eso es de 1,5 millones Eso es bastante grande) 1525198