Come devo memorizzare le serie temporali in mongodb

Devo creare un database di serie temporali ed eseguire le seguenti attività:

• creare nuove serie storiche
• aggiorna le serie temporali esistenti
• interrogare una o più serie temporali contemporaneamente (ad esempio tutte le serie temporali per la stessa data, ecc ...)

Mongo è adattato a questo e se sì, come dovrei strutturare il database? (una serie temporale = un documento? O un documento = una voce della serie temporale e tutti questi documenti formano la raccolta che è l'intera serie temporale?)

Mi sono perso un po 'qui e trovo difficile trovare qualsiasi informazione dato che solitamente Mongo è presentato in modo molto flessibile, quindi l'utente ha la possibilità di scegliere nell'infrastruttura.

Qualsiasi link a tutorial che spieghi specificamente come gestire le serie temporali in Mongo è molto gradito.

Grazie!

Suggerisco una singola voce di serie storica per documento. Esistono alcuni problemi con la memorizzazione di più voci per documento:

• un singolo documento è limitato a una determinata dimensione (attualmente 16 MB); questo limita quante voci possono essere memorizzate in un singolo documento
• man mano che vengono aggiunte più voci a un documento, l'intero documento (e le serie temporali) verranno inutilmente eliminati e riallocati in un pezzo di memoria più grande
• le query sui documenti secondari sono limitate rispetto alle query sui documenti normali
• i documenti con strutture molto piatte (come un sotto-documento per ogni secondo) non sono performanti
• la riduzione integrata della mappa non funziona altrettanto bene sui documenti secondari

Si noti inoltre che un timestamp è incorporato nell'IdI MongoDB predefinito . Puoi usarlo se la precisione della serie temporale è inferiore a un secondo.

Ecco un esempio di documento BSON da una libreria di registrazione eventi che utilizza MongoDB :

Example format of generated bson document:
{
    'thread': -1216977216,
    'level': 'ERROR',
    'timestamp': Timestamp(1290895671, 63),
    'message': 'test message',
    'fileName': '/var/projects/python/log4mongo-python/tests/test_mongo_handler.py',
    'lineNumber': 38,
    'method': 'test_emit_exception',
    'loggerName':  'testLogger',
    'exception': {
        'stackTrace': 'Traceback (most recent call last):
                       File "/var/projects/python/log4mongo-python/tests/test_mongo_handler.py", line 36, in test_emit_exception
                       raise Exception(\'exc1\')
                       Exception: exc1',
        'message': 'exc1',
        'code': 0
    }
}

Poiché un registro eventi è simile a una serie temporale, può valere la pena studiare il resto del codice . Esistono versioni in Java, C #, PHP e Python.

Ecco un altro progetto open source simile: Zarkov

[aggiornamento] In risposta al commento di @ RockScience, ho aggiunto altri riferimenti:

• Case study molto dettagliato su come MongoDB è stato utilizzato per memorizzare le serie storiche . Parti interessanti:
  • Diapositiva 25: quanti dati? 20 punti dati a 4 byte a intervalli di 1 minuto per 10 anni (non è evidente se si tratta di statistiche effettive o solo stime previste)
  • Diapositiva 66: mostra un documento MongoDB di esempio utilizzato per archiviare i dati delle serie storiche
• Best practice per l'archiviazione dei dati di registro , direttamente dai creatori di MongoDB

Ho trovato questa domanda su SO ( /programming/4814167/storing-time-series-data-relational-or-non ) dove l'OP chiede come archiviare una serie temporale. Sebbene la sua domanda sia più basata sull'utilizzo di un database NoSQL o di un RDBMS, e sembri piuttosto pronto a utilizzare un db NoSQL.

Inoltre, ho trovato questo articolo su " Requisiti univoci del database per i dati di serie storiche " che potrebbe essere utile.

Spero che questo ti aiuti.

Sì, sicuramente, il database NoSQL si adatta meglio alla memorizzazione dei dati di timeseries rispetto al tradizionale RDBMS.

Sì MongoDB è eccezionalmente adattato a questo caso d'uso.

-Come dovresti strutturare il database? Un documento = input di una serie storica VS più serie temporali.

La risposta è archiviare in un documento più timeseries. Avere meno documenti aiuterà le prestazioni con meno letture. Un trucco è preparare il documento con i valori predefiniti. Ciò ottimizzerà l'aggiornamento del documento evitando il Record Padding .

Ecco un esempio di schema su come archiviare in modo ottimale un'ora di timeseries con un intervallo di minuti:

{
  timestamp_hour: ISODate("2015-07-02T23:00:00.000Z"),
  type: “memory_used”,
  values: {
    0: 999999,
    1: 1000000, 
    …,
    58: 0,
    59: 0
  }
}

Lo si avvia con 0 valori e quindi gli aggiornamenti verranno ottimizzati. Le letture sono ottimizzate perché viene letto un documento anziché 60. Se è necessario archiviare un giorno di dati o un mese si procede con la stessa tecnica, si ottiene l'idea.

Ecco il link a un tutorial che spiega specificamente come gestire le serie temporali in MongoDb dal blog ufficiale MongoDb: http://blog.mongodb.org/post/65517193370/schema-design-for-time-series-data-in- MongoDB