Mejores prácticas para recopilaciones de series temporales

Escritura de documentos por lotes

Al insertar varios documentos:

• Para evitar viajes de ida y vuelta en la red, utilice una sola insertMany()Declaración en lugar de múltiples insertOne() declaraciones.

• Si es posible, compón lotes que contengan varias mediciones por serie (según lo definido por los metadatos).

• Para mejorar el rendimiento, establece el parámetro ordered en false.

Por ejemplo, si tiene dos sensores, sensor A y sensor B, un lote que contiene múltiples mediciones de un solo sensor incurre en el costo de una inserción, en lugar de una inserción por medición.

La siguiente operación inserta seis documentos, pero solo cuesta dos inserciones (una por lote), ya que los documentos se ordenan por sensor. El parámetro ordered se establece en false para mejorar el rendimiento:

db.temperatures.insertMany( [
   {
      "metadata": {
         "sensor": "sensorA"
      },
      "timestamp": ISODate("2021-05-18T00:00:00.000Z"),
      temperature: 10
   },
   {
      "metadata": {
         "sensor": "sensorA"
      },
      "timestamp": ISODate("2021-05-19T00:00:00.000Z"),
      temperature: 12
   },
   {
      "metadata": {
         "sensor": "sensorA"
      },
      "timestamp": ISODate("2021-05-20T00:00:00.000Z"),
      temperature: 13
   },
   {
      "metadata": {
         "sensor": "sensorB"
      },
      "timestamp": ISODate("2021-05-18T00:00:00.000Z"),
      temperature: 20
   },
   {
      "metadata": {
         "sensor": "sensorB"
      },
      "timestamp": ISODate("2021-05-19T00:00:00.000Z"),
      temperature: 25
   },
   {
      "metadata": {
         "sensor": "sensorB"
      },
      "timestamp": ISODate("2021-05-20T00:00:00.000Z"),
      temperature: 26
   }
], {
   "ordered": false
})

Utilice un orden de campos coherente en los documentos

El uso de un orden de campos coherente en sus documentos mejora el rendimiento de inserción.

Por ejemplo, al insertar estos documentos se consigue un rendimiento de inserción óptimo:

{
   _id: ObjectId("6250a0ef02a1877734a9df57"),
   timestamp: 2020-01-23T00:00:00.441Z,
   name: 'sensor1',
   range: 1
},
{
   _id: ObjectId("6560a0ef02a1877734a9df66")
   timestamp: 2020-01-23T01:00:00.441Z,
   name: 'sensor1',
   range: 5
}

Por el contrario, estos documentos no alcanzan un rendimiento de inserción óptimo, porque sus órdenes de campos difieren:

{
   range: 1,
   _id: ObjectId("6250a0ef02a1877734a9df57"),
   name: 'sensor1',
   timestamp: 2020-01-23T00:00:00.441Z
},
{
   _id: ObjectId("6560a0ef02a1877734a9df66")
   name: 'sensor1',
   timestamp: 2020-01-23T01:00:00.441Z,
   range: 5
}

Aumentar el número de clientes

Aumentar la cantidad de clientes que escriben datos en sus colecciones puede mejorar el rendimiento.

Omitir campos que contienen objetos y matrices vacíos de los documentos

Para optimizar la compresión, si sus datos contienen objetos vacíos o arreglos, omita los campos vacíos de sus documentos.

Por ejemplo, considere los siguientes documentos:

{
 time: 2020-01-23T00:00:00.441Z,
 coordinates: [1.0, 2.0]
},
{
   time: 2020-01-23T00:00:10.441Z,
   coordinates: []
},
{
   time: 2020-01-23T00:00:20.441Z,
   coordinates: [3.0, 5.0]
}

La alternancia entre los campos coordinates con valores rellenados y una matriz vacía da como resultado un cambio de esquema en el compresor. Este cambio hace que el segundo y el tercer documento de la secuencia permanezcan sin comprimir.

Por el contrario, los siguientes documentos donde se omite la matriz vacía reciben el beneficio de una compresión óptima:

{
   time: 2020-01-23T00:00:00.441Z,
   coordinates: [1.0, 2.0]
},
{
   time: 2020-01-23T00:00:10.441Z
},
{
   time: 2020-01-23T00:00:20.441Z,
   coordinates: [3.0, 5.0]
}

Redondear datos numéricos a unos pocos decimales

Redondee los datos numéricos a la precisión requerida por su aplicación. Redondear los datos numéricos a menos decimales mejora la tasa de compresión.

Utilice $group en lugar de Distinct()

Debido a la estructura de datos única de las colecciones de series temporales, MongoDB no puede indexarlas eficientemente para valores distintos. Evite usar el distinct comando o db.collection.distinct() el método auxiliar en colecciones de series temporales. En su lugar, utilice una $group agregación para agrupar documentos por valores distintos.

Por ejemplo, para query valores meta.type distintos en documentos donde meta.project = 10, en lugar de:

db.foo.distinct("meta.type", {"meta.project": 10})

Uso:

db.foo.createIndex({"meta.project":1, "meta.type":1})
db.foo.aggregate([{$match: {"meta.project": 10}},
                  {$group: {_id: "$meta.type"}}])

Esto funciona de la siguiente manera:

1. Crea un índice compuesto meta.project en meta.type y y admite la agregación.

2. La $match etapa filtra los documentos meta.project = 10 donde.

3. La etapa $group utiliza meta.type como clave de grupo para generar un documento por valor único.