Collections

Nesta página

Coleções de Time Series

Capped collections
Converter uma collection existente em limitada
Validação do documento
Adicionar validação a uma collection existente
Listando collection
Eliminando collection

O MongoDB armazena documento em collection. Se uma collection não existir, o MongoDB criará a collection quando você inserir pela primeira vez um documento nessa collection.

Você também pode criar explicitamente uma collection com várias opções, como definir o tamanho máximo ou as regras de validação da documentação.

Coleções de Time Series

As coleções de séries temporais foram adicionadas no MongoDB 5.0. Você pode ler a documentação aqui.

A coleção de séries temporais armazena sequências de medições de forma eficiente ao longo de um período de tempo. Dados de time-series são quaisquer dados coletados ao longo do tempo e identificados exclusivamente por um ou mais parâmetros imutáveis. Os parâmetros imutáveis que identificam seus dados de time-series geralmente são os metadados do seu conjunto de dados.

Criar uma coleção de time-series collection

Para criar uma coleção de séries temporais, você deve criar explicitamente uma coleção usando as opções de séries temporais:

opts = {
  time_series: {
    timeField: "timestamp",
    metaField: "metadata",
    granularity: "hours"
  },
  expire_after: 604800
}
db['weather', opts].create

Ao criar uma coleção de séries temporais, especifique as seguintes opções:

Campo	Descrição
`time_series[:timeField]`	Obrigatório. O nome do campo que contém a data em cada documento da série temporal.
`time_series[:metaField]`	Opcional. O nome do campo que contém metadados em cada documento de série temporal. Os metadados no campo especificado devem ser dados utilizados para rotular uma série exclusiva de documentos. Os metadados devem mudar raramente ou nunca.
`time_series[:granularity]`	Opcional. Os valores possíveis são "segundos", "minutos" e "horas". Por padrão, o MongoDB define a granularidade como "segundos" para ingestão de alta frequência.
`:expireAfterSeconds`	Opcional. Ative a exclusão automática de documentos em uma coleção de séries temporais especificando o número de segundos após os quais os documentos expiram. O MongoDB exclui documentos expirados automaticamente.

MongoDB Docs Consulte os do para obter mais informações sobre as opções de coleção de séries temporais.

Inserção em uma coleção de time-series

A inserção em uma coleção de séries temporais é semelhante à inserção em uma coleção regular:

db['weather'].insert_many([
  {
      metadata: { sensorId: 5578, type: "temperature" },
      timestamp: Time.utc(2021, 5, 18, 0, 0, 0),
      temp: 12
  },
  {
      metadata: { sensorId: 5578, type: "temperature" },
      timestamp: Time.utc(2021, 5, 18, 4, 0, 0),
      temp: 11
  },
  {
      metadata: { sensorId: 5578, type: "temperature" },
      timestamp: Time.utc(2021, 5, 18, 8, 0, 0),
      temp: 11
  },
  {
      metadata: { sensorId: 5578, type: "temperature" },
      timestamp: Time.utc(2021, 5, 18, 12, 0, 0),
      temp: 12
  },
  {
      metadata: { sensorId: 5578, type: "temperature" },
      timestamp: Time.utc(2021, 5, 18, 16, 0, 0),
      temp: 16
  },
  {
      metadata: { sensorId: 5578, type: "temperature" },
      timestamp: Time.utc(2021, 5, 18, 20, 0, 0),
      temp: 15
  }, {
      metadata: { sensorId: 5578, type: "temperature" },
      timestamp: Time.utc(2021, 5, 19, 0, 0, 0),
      temp: 13
  },
  {
      metadata: { sensorId: 5578, type: "temperature" },
      timestamp: Time.utc(2021, 5, 19, 4, 0, 0),
      temp: 12
  },
  {
      metadata: { sensorId: 5578, type: "temperature" },
      timestamp: Time.utc(2021, 5, 19, 8, 0, 0),
      temp: 11
  },
  {
      metadata: { sensorId: 5578, type: "temperature" },
      timestamp: Time.utc(2021, 5, 19, 12, 0, 0),
      temp: 12
  },
  {
      metadata: { sensorId: 5578, type: "temperature" },
      timestamp: Time.utc(2021, 5, 19, 16, 0, 0),
      temp: 17
  },
  {
      metadata: { sensorId: 5578, type: "temperature" },
      timestamp: Time.utc(2021, 5, 19, 20, 0, 0),
      temp: 12
  }
])

Consultando uma coleção de séries temporais

A query de uma coleção de séries temporais também é muito semelhante a uma collection regular:

weather.find(timestamp: Time.utc(2021, 5, 18, 0, 0, 0)).first

O resultado desta query:

{
  "timestamp" => 2021-05-18 00:00:00 UTC,
  "metadata" => {
    "sensorId" => 5578,
    "type" => "temperature"
  },
  "temp" => 12,
  "_id" => BSON::ObjectId('624dfb87d1327a60aeb048d2')
}

Usando o pipeline de agregação em uma coleção de séries temporais

O aggregation pipeline também pode ser usado para funcionalidade de query adicional:

weather.aggregate([
  {
    "$project": {
      date: {
        "$dateToParts": { date: "$timestamp" }
      },
      temp: 1
    }
  },
  {
    "$group": {
      _id: {
        date: {
          year: "$date.year",
          month: "$date.month",
          day: "$date.day"
        }
      },
      avgTmp: { "$avg": "$temp" }
    }
  }
]).to_a

O exemplo de aggregation pipeline grupos todos os documentos pela data da medição e, em seguida, retorna a média de todas as medições de temperatura daquele dia:

[{
  "_id" => {
    "date" => {
      "year" => 2021,
      "month" => 5,
      "day" => 18
    }
  },
  "avgTmp" => 12.833333333333334
},
{
  "_id" => {
    "date" => {
      "year" => 2021,
      "month" => 5,
      "day" => 19
    }
  },
  "avgTmp" => 12.833333333333334
}]

Consulte a documentação do MongoDB sobre coleções de séries temporais para obter mais informações.

Capped collections

Coleções limitadas têm tamanho máximo ou contagens de documentos que as impedem de crescer além dos limites máximos. Todas as coleções limitadas devem especificar um tamanho máximo e também podem especificar uma contagem máxima de documentos. O MongoDB remove documentos mais antigos se uma coleção atingir o limite de tamanho máximo antes de ela atingir a contagem máxima de documentos.

Para criar uma capped collection, use a opção capped: true junto com um size em bytes.

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
collection = client[:artists, capped: true, size: 10000]
collection.create
collection.capped? # => true

Converter uma collection existente em limitada

Para converter uma collection existente de sem limite para limitada, use o comando convertToCapped .

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
db = client.database
db.command({ 'convertToCapped' => 'artists', 'size' => 10000 })

Validação do documento

Se você estiver usando o MongoDB versão 3.2 ou posterior, poderá usar a validação de documento. Coleções com validações comparam cada documento inserido ou atualizado com os critérios especificados na opção validador. Dependendo do validationLevel e validationAction, o MongoDB retorna um aviso ou se recusa a inserir ou atualizar o documento se ele não atender aos critérios especificados.

O exemplo a seguir cria uma collection contacts com um validador que especifica que os documento inseridos ou atualizados devem corresponder a pelo menos uma das três condições a seguir:

o campo phone é uma string
o campo email corresponde à expressão regular
o campo status é Unknown ou Incomplete.

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'test')
client[:contacts,
    {
       'validator' => { '$or' =>
          [
             { 'phone' => { '$type' => "string" } },
             { 'email' => { '$regex' => /@mongodb\.com$/ } },
             { 'status' => { '$in' => [ "Unknown", "Incomplete" ] } }
          ]
       }
    }
  ].create

Adicionar validação a uma collection existente

Para adicionar critérios de validação do documento a uma collection existente, use o comando collMod . O exemplo abaixo demonstra como adicionar uma validação à collection contacts , garantindo que todos os novos documentos contenham um campo age que é um número.

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'test')
db = client.database
db.command({ 'collMod' => 'contacts',
             'validator' =>
               { 'age' =>
                 { '$type' => "number" }
               }
           })

Listando collection

Use os métodos collections ou collection_names em objeto de reconhecimento de data center para listar collection:

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
database = client.database
database.collections      # Returns an array of Collection objects.
database.collection_names # Returns an array of collection names as strings.

Eliminando collection

Para eliminar uma collection, chame drop no objeto da collection.

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
artists = client[:artists]
artists.drop

Voltar

Bancos de dados

Indexação