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


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


50
2018-03-16 20:48


origen


Respuestas:


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

Realmente, lo que estás haciendo con un hallazgo es:

db.collectionName.find(queryDoc)

donde 'queryDoc' es algo así como:

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

Para encontrar la cantidad máxima de valores que puede pasar a una consulta $ in, use la bsonsize mando:

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, puede 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

Entonces, sin importar el tamaño de un número individual, es el mismo bsonsize.

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

Sumando esto para una consulta de campo con una cláusula $ in, en pymongo, a través de la solicitud javascript de mongos, lo que sea, todos los datos de adición para el tamaño máximo de una consulta $ in:

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.

Entonces, suponiendo que tiene un nombre de campo de un byte (el mínimo, realmente), su máximo es:

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

LA RESPUESTA: 1,525,198  (Eso es 1.5 millones. Eso es bastante grande.)


62
2017-08-28 18:23



Parece que no hay limitación.

Hice una pequeña prueba.

1) Colección A tenía - 1 millón de objetos JSON simples {id:, name:}

2) En la Colección B, cargué identificadores de referencia de la colección A hasta que obtuve 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 450k de estos ids como $ en [id1 ... id450000] y extraer toda la lista de 450k ids de 1 millón de objetos en la colección A.

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


34
2018-03-17 01:34



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: ¿Está bien consultar un MongoDB varias veces por solicitud?

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.


6
2018-03-17 09:49