mejores prácticas para colección de series de tiempo

Guardar documentos agrupar

Al insertar varios documentos:

• Para evitar viajes de ida y vuelta a la red, utiliza un único 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
})

Usa orden de campo coherente en los documentos

Utilizar un orden de campos coherente en los documentos mejora el rendimiento de las inserciones.

Por ejemplo, insertar estos documentos ofrece 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 logran un rendimiento óptimo de inserción 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

Incrementar el número de clientes que escriben datos en las 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 completados y un arreglo vacío da como resultado un cambio en el esquema del compresor. El cambio de esquema provoca que el segundo y el tercer documento en la secuencia permanezcan sin comprimir.

En cambio, los siguientes documentos, en los que se omite el arreglo vacío, reciben el beneficio de la 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]
}

Redondea los 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.

Utiliza $group en vez de Distinct()

Debido a la estructura única de datos de las colecciones de series temporales, MongoDB no puede indexarlas eficientemente para valores distintos. Evite utilizar el comando distinct o el método asistente db.collection.distinct() en colecciones de series temporales. En su lugar, use 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. Creando un índice compuesto en meta.project y meta.type y admite la agregación.

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

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