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

  • Leí en alguna parte que es 1 000 000.
  • Vea a continuación para el cálculo real con el trabajo que se muestra.
InformationsquelleAutor Deepan | 2011-03-16

3 Comentarios

  1. 80

    La de la consulta en sí es un documento . MongoDB límites de los tamaños de documento (de la versión 2.4.0+) a 16 MB.

    Realmente, lo que estamos haciendo es encontrar un:

    db.collectionName.find(queryDoc)

    donde ‘queryDoc’ es algo así como:

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

    Para encontrar el máximo número de valores que puede pasar a un $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

    Así, se puede ver que cada entero es el tamaño de 11 bytes. No 11 bits, 11 BYTES. Esto es debido a la forma en que BSON almacena internamente los números como mínimo de 64 bits cada uno, además de la envoltura. Esto puede ser visto 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

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

    En la Propia Pregunta: ¿Cómo es de grande que el documento de consulta?

    La adición de estos para una consulta de campo con un $en la cláusula, en pymongo, a través de los mongos de javascript rápida, lo que sea, todo el rendimiento de la misma, además de los hechos para el tamaño máximo de un $en 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í es de 22 bytes;
    • Cada byte del campo nombre se agrega un solo byte;
    • Cada número añadido a la $en la cláusula añade 11 bytes.

    Así, supongamos que usted tiene un de un byte fieldname (el mínimo, la verdad), 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: 1,525,198 (Que es de 1,5 millones de euros. Que es bastante grande.)

    • Esta respuesta debe ser aceptado.
  2. 35

    Parece que no hay limitación.

    Hice una pequeña prueba.

    1) de la Colección de Un ha – 1 Millones de simple objeto JSON {id:,nombre:}

    2) En la Colección B, me cargan ids de referencia de la colección hasta que llegué a la siguiente excepción. Yo podría insertar un número de referencia de 450k de max.

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

    3) me podría enviar 450k de estos identificadores como $en[id1…id450000] y tire de la totalidad de la lista de 450k identificadores de 1 Millón de objetos en la colección de A.

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

    • +1 para la diversión de los experimentos
  3. 7

    Creo que la limitación sólo está determinado por el tamaño de un BSONDocument. Cuando se define una consulta, usted puede mantener la adición de los valores en un $en la cláusula hasta que supere el tamaño máximo de documento. Entonces, ¿cómo muchos de los valores que puede tener en la cláusula depende de cómo de grande cada valor es (el más pequeño es el tamaño de cada valor, más se puede incluir en el $en la cláusula where).

    En términos de rendimiento, por lo que he encontrado, hay un «punto dulce» para el número de valores en un $en la cláusula. Ver mi respuesta en esta pregunta relacionada con: Es ACEPTAR a la consulta de un MongoDB varias veces por solicitud?

    es decir, de equilibrio número de valores en $en la cláusula vs número de consultas enviadas. Estoy a mitad de camino a través de un blog en el que probar y sumergirse en más detalle.

Dejar respuesta

Please enter your comment!
Please enter your name here