Melhores práticas para Coleções de séries temporais

Gravações de documentos em lote

Ao inserir vários documentos:

• Para evitar viagens de ida e volta de rede, use um único comando insertMany() em vez de vários comandos insertOne().

• Se possível, construa lotes para conter múltiplas medições por série (conforme definido pelos metadados).

• Para melhorar o desempenho, defina o parâmetro ordered para false.

Por exemplo, se você tiver dois sensores, sensor A e sensor B, um lote contendo múltiplas medições de um único sensor incorrerá no custo de uma inserção, em vez de uma inserção por medida.

A operação a seguir insere seis documentos, mas só incorre no custo de duas inserções (uma por lote), pois os documentos são ordenados por sensor. O parâmetro ordered está configurado para false para melhorar o desempenho:

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
})

Usar ordem de campo consistente em documentos

Usar uma ordem de campo consistente em seus documentos melhora o desempenho da inserção.

Por exemplo, a inserção destes documentos proporciona um desempenho de inserção ideal:

{
   _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 outro lado, esses documentos não alcançam o desempenho ideal de inserção, porque suas ordens de campo diferem:

{
   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 o número de clientes

Aumentar o número de clientes que gravam dados em suas coleções pode melhorar o desempenho.

Campos de omissão contendo objetos vazios e arrays de documentos

Para otimizar a compressão, se os dados contiverem objetos ou arrays vazios, omita os campos vazios dos documentos.

Por exemplo, considere os seguintes 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]
}

A alternância entre campos coordinates com valores preenchidos e uma array vazia resulta em uma alteração de esquema para o compressor. A mudança de esquema faz com que o segundo e o terceiro documentos da sequência permaneçam descompactados.

Em contraste, os seguintes documentos em que a array vazia é omitida recebem o benefício da compressão ideal:

{
   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]
}

Arredondar dados numéricos para poucos locais decimais

Arredonde os dados numéricos com a precisão necessária para sua aplicação. O arredondamento dos dados numéricos para menos casas decimais melhora a taxa de compactação.

Use $group em vez de Distinct()

Devido à estrutura de dados única das coleções de séries temporais, o MongoDB não pode indexá-las de forma eficiente para valores diferentes. Evite usar o comando distinct ou método assistente db.collection.distinct() em coleções de séries temporais. Em vez disso, use uma agregação $group para agrupar documentos por valores distintos.

Por exemplo, para consultar valores meta.type diferentes em documentos onde meta.project = 10, em vez de:

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

Usar:

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

Isso funciona da seguinte maneira:

1. Criando um índice composto em meta.project e meta.type e é compatível com a agregação.

2. O estágio $match filtra documentos onde meta.project = 10.

3. O estágio $group usa meta.type como a chave de grupo para gerar um documento por valor exclusivo.