Data Warehouse: come posso eseguire una query sulle istantanee quotidiane?

Ho alcune istantanee di un database che non sono multiproprietà. Per esempio:

• Snapshot day 1:

  +----+---------------+------------+------------+        
  | ID |     Title     |  Category  |    Date    |
  +----+---------------+------------+------------+
  | 1  | My First Post | helloworld | 2015-01-01 |
  +----+---------------+------------+------------+
  

• Snapshot day 2 (un nuovo post è stato aggiunto oggi):

  +----+----------------+------------+------------+        
  | ID |      Title     |  Category  |    Date    |
  +----+----------------+------------+------------+
  | 1  | My first post  | helloworld | 2015-01-01 |
  | 2  | My second post | other      | 2015-01-02 |
  +----+----------------+------------+------------+
  

• Snapshot day 3 (Post 2 viene rimosso oggi):

  +----+---------------+------------+------------+        
  | ID |     Title     |  Category  |    Date    |
  +----+---------------+------------+------------+
  | 1  | My First Post | helloworld | 2015-01-01 |
  +----+---------------+------------+------------+
  

Quindi, tra giorni, una riga della tabella può essere o meno costante. Ora, devo essere in grado di utilizzare una query come questa:

SELECT category, COUNT(*) from day1.My_table group by category

Questo è per una tabella di un giorno. Se vogliamo contare la media giornaliera dei post per categoria in un mese , dovremmo fare qualcosa del tipo:

SELECT category, SUM(cnt) / 30 
from ( 
    SELECT category, COUNT(*) as cnt 
    from day1.My_table 
    group by category 
        UNION ALL SELECT category, COUNT(*) as cnt 
                  from day2.My_table 
                  group by category 
        UNION ALL ... 
        UNION ALL SELECT category, COUNT(*) as cnt 
                  from day30.My_table 
                  group by category
) group by category

Un altro esempio, il numero di post pubblicati in un mese :

SELECT COUNT(distinct id) 
from ( 
    SELECT id 
    from day1.My_table 
    UNION ALL ... 
    UNION ALL SELECT id 
              from day30.My_table
) 

Fondamentalmente dovremmo considerare un peso. Se abbiamo day1.My_table e day5.My_table, ogni post che si trova nel day1 e non nel day5 verrà conteggiato come lo era anche nel day 2,3,4. Ogni post che è day1 e day5 verrà conteggiato come se fosse presente in tutti i giorni del mese (= fino all'istantanea successiva).

Quindi, nel caso in cui vorrei considerare il numero medio di post al giorno di> = 6 mesi alla volta, dove ho solo 1 istantanea, assegnerei a quella istantanea un peso di 30.

Quindi, il post medio pubblicato in un mese per un intervallo> = 6 mesi fa è:

SELECT category, SUM(cnt) / 30 
from ( 
    SELECT category, COUNT(*)*30 as cnt 
    from day1.My_table 
    group by category --- Note: I'm not considering the range defined from the user in this example.
) group by category;

Come anche il commento ha affermato, avrei bisogno di fare una query come:

Select category, AVG(*) 
from [fromRange-toRange].MyTable; 

Per una soluzione estrema, sto prendendo in considerazione l'idea di implementare un metalinguaggio per consentire all'utente futuro (es. Persone di marketing) di fare una query come questa.

Pensi che ci sia un modo per farlo in Drill senza il meta-linguaggio? Lo farei usando un UDF ricorsivo ma non possono restituire query.

Ogni istantanea ha una dimensione di 250 GB e voglio poter confrontare questi set di dati con altri dati esterni (non conosco in anticipo lo schema di questi set di dati).

Esiste una soluzione adatta per Apache Drill? O c'è un'altra soluzione per questo problema?

Anche qualsiasi meta-lingua o articolo su questo problema è apprezzato.

Modifica: non abbiamo dati transazionali. Abbiamo dati che cambiano nel tempo e possono essere aggiunti o rimossi; per questo motivo abbiamo bisogno di istantanee di tutti i giorni. Inoltre non conosciamo in anticipo le query che verranno eseguite, quindi non possiamo sapere quale tipo di aggregazione debba essere eseguita. Inoltre ogni riga ha circa 100 colonne e ci sono 250 GB per istantanea (tabelle Mysql). Abbiamo anche bisogno di una ricerca full-text su questi dati su ogni riga, ogni giorno possibile.

Un esempio di ricerca potrebbe essere "Quanti post riguardavano qualcosa diopopico?" Quindi deve cercare in tutti i post la parola chiave sometopic. Ogni istantanea può avere o meno le stesse righe. Anche due istantanee potrebbero avere lo stesso post, ma leggermente modificate.

Pensiamo fuori dagli schemi. Invece di avere uno "snapshot", facciamo un "log". Quello che hai attualmente è lo stato "attuale" delle cose; l'aggiunta di un "registro" fornirebbe la "cronologia", da cui potrebbero derivare le informazioni "perse".

Un modo per implementare il registro è avere un TRIGGERon INSERTo UPDATEdella tabella e fare in modo che il trigger scriva nel file di registro. Questo registro non sarà piacevole per le query ad hoc, quindi procurati un lavoro notturno (o forse orario) che sintetizzi le modifiche per il giorno: guadagno (o perdita) netto del numero di post, ecc. Le informazioni "day2" e le informazioni "ultimo mese" possono quindi essere derivate da questa tabella di riepilogo abbastanza rapidamente. O forse un secondo livello di riassunto che dichiara lo stato per ogni giorno. Dubito che UNIONsarebbe necessario. Lo "snapshot" non verrebbe coinvolto.

Quindi quello che stavo cercando, è un nuovo tipo di sistema correlato a Datawarehousing: Data Lake System.

Puoi saperne di più su Wikipedia :

Un lago di dati è un metodo di archiviazione dei dati all'interno di un sistema che facilita il colocation dei dati in schemi varianti e forme strutturali, generalmente BLOB di oggetti o file. Hadoop e la piattaforma AWS S3 possono essere utilizzati per creare repository di data lake.