Gestione di più tabelle dei fatti in Qlikview

Question

Ho un database PostgreSQL contenente vari dati sull'educazione quali i punteggi dei test a livello di scuola e le cifre di iscrizione. Devo separare l'iscrizione dai punteggi dei test perché i dati sono su diversi grani. Anche se l'iscrizione è su una granularità diversa dai dati del punteggio del test, molte delle dimensioni sono le stesse. Ad esempio, ho:

~ ---------------------------------------------------------------------------------~ 
| Test Scores Fact                 | 
|-------------|-----------|----------|-----------|--------------|------------|-----| 
| school_code | test_code | grade_id | gender_id | ethnicity_id | subject_id | ... | 
|-------------|-----------|----------|-----------|--------------|------------|-----| 

~ --------------------------------------------------------~ 
| Enrollment Fact           | 
|-------------|----------|-----------|--------------|-----| 
| school_code | grade_id | gender_id | ethnicity_id | ... | 
|-------------|----------|-----------|--------------|-----| 

Questa struttura è bene sul backend, ma in QlikView, questo crea una chiave sintetica. La soluzione per le chiavi sintetiche sembra di solito sostituirla con una tabella di collegamenti tramite lo script di Qlikview, che è stato anche il mio approccio. Ma questo non sembra scalare, come quando aggiungo una terza tabella dei fatti (su un altro chicco) che contiene più delle stesse dimensioni, se creo un'altra tabella di collegamento, ora le mie due tabelle di collegamento iniziano ad associarsi in quanto contengono più comunemente campi con nome, e la risposta di Qlikview è di creare più chiavi sintetiche?

Sono relativamente nuovo a Qlikview e sto lavorando da solo. Come vengono gestiti in genere più fatti di diversi grani con dimensioni comuni?

EDIT:

ho fornito la mia soluzione a questo problema, che ha lavorato in un ambiente di produzione per poco meno di un anno! Vedere la mia risposta qui sotto ...

Answer 1

Visto la popolarità di questa domanda, aggiungerò la mia vera soluzione al mix in modo che le persone abbiano un esempio da cui lavorare, che per qualche motivo è davvero difficile da trovare per un problema così comune ...

Ho proceduto alla creazione di una tabella di collegamento. Questa soluzione fino ad oggi sembra un trucco perché crea un enorme tavolo contenente il prodotto cartesiano di ciascuna delle tue chiavi in ​​tutte le tabelle dei fatti ... ma funziona.

Il problema: nel database sono presenti più tabelle dei fatti; un'occorrenza in quasi tutti i database di sempre. Alcune (o tutte) di queste tabelle dei fatti condividono gli stessi campi chiave; nessun problema, giusto? Sbagliato. Sfortunatamente, a causa della natura associativa di Qlik, invece di ciascuna delle tabelle dei fatti che si collegano bene alle loro tabelle di ricerca, le tabelle dei fatti ora si associano tra loro e provocano il caos sul modello dei dati; creare riferimenti circolari e quantità incalcolabili di chiavi sintetiche.

La soluzione: creare una tabella di collegamento. Sembra semplice, giusto? Beh, lo è, ma è anche molto scarsamente documentato e difficile da capire senza una spiegazione iniziale. Forse ti starai chiedendo ... cos'è un Link Table? È il prodotto cartesiano di tutte le chiavi di tutte le tabelle dei fatti. In che modo questo corregge il problema? Rimuove tutte le associazioni indesiderate tra le tabelle dei fatti poiché ciascuna di esse contiene ora una sola chiave concatenata univoca. Queste uniche chiavi si assoceranno solo alla tabella di collegamento, che contiene tutte le chiavi concatenate univoche e tutte le singole chiavi. La Tabella collegamenti verrà successivamente associata alle tue tabelle di ricerca e tutto andrà bene.

Implementazione:

Questa implementazione userà i due tabelle contenute nella mia domanda di cui sopra; test_scores_fact e enrollment_fact.

test_scores_fact  | enrollment_fact  | school   | gender   | ... 
----------------  | ---------------  | ------   | ------   | --- 
school_code (FK)  | school_code (FK)  | school_code (PK) | gender_id (PK) | 
test_code (FK)  | grade_id (FK)  | school_name (FK) | gender_desc | 
grade_id (FK)  | ethnicity_id (FK) | address   | ...   | 
gender_id (FK)  | gender_id (FK)  | ...    | 
ethnicity_id (FK) | number_enrolled (F) | 
subject_id (FK)  | 
test_score (F)  | 

FK = Foreign Key 
PK = Primary Key 
F = Fact 

Come si può vedere, le due tabelle dei fatti hanno le chiavi sovrapposte, school_code, grade_id, gender_id e ethnicity_id. In un modello relazionale, ogni campo chiave ha una tabella corrispondente con informazioni aggiuntive sulla chiave. Questo modello non fa parte della natura associativa di Qlikview in quanto Qlikview associa le tabelle in base al nome di un campo; anche quando non lo vuoi. Si desidera che i campi denominati vengano associati alle rispettive tabelle di ricerca, tuttavia non si desidera che i campi denominati nelle tabelle dei fatti vengano associati. Sfortunatamente non puoi fermare questo comportamento. Devi implementare una tabella di link ...

1. Nel vostro script di QlikView, creare una tabella dei fatti temporanea, che carica in tutti i campi della tua tabella di database:

   [temp_test_scores]: 
   LOAD school_code, 
       test_code, 
       grade_id, 
       gender_id, 
       ethnicity_id, 
       subject_id, 
       test_score; 
   SQL SELECT * FROM <database connection> 
   

2. Concatenare le chiavi e rimuovere tutti i singoli tasti:

   [test_scores]: 
   LOAD school_code & '_' test_code & '_' grade_id & '_' gender_id & '_' ethnicity_id & '_' subject_id as test_key, 
       test_score 
   RESIDENT [temp_test_scores]; 
   

3. Ripetere i passaggi 1 & 2 per ogni tabella dei fatti:

   [temp_enrollment]: 
   LOAD school_code, 
       grade_id, 
       ethnicity_id, 
       gender_id, 
       number_enrolled; 
   SQL SELECT * FROM <database connection> 
   
   [enrollment]: 
   LOAD school_code & '_' & grade_id & '_' & ethnicity_id & '_' & gender_id as enrollment_key, 
       number_enrolled 
   RESIDENT [temp_enrollment]; 
   

4. Crea la tabella di collegamento concatenando le chiavi individuali in un'unica tabella:

   [temp_link_table]: 
   LOAD DISTINCT 
       school_code, 
       test_code, 
       grade_id, 
       gender_id, 
       ethnicity_id, 
       subject_id 
   RESIDENT [temp_test_scores]; 
   
   CONCATENATE ([temp_link_table]) 
   LOAD DISTINCT 
       school_code, 
       grade_id, 
       ethnicity_id, 
       gender_id, 
       number_enrolled 
   RESIDENT [temp_enrollment]; 
   
   /** 
   * The final Link Table will contain all of the individual keys one time as well as your concatenated keys 
   */ 
   [link_table]: 
   LOAD DISTINCT 
       school_code, 
       test_code, 
       grade_id, 
       gender_id, 
       ethnicity_id, 
       subject_id, 
       school_code & '_' test_code & '_' grade_id & '_' gender_id & '_' ethnicity_id & '_' subject_id as test_key, 
       school_code & '_' & grade_id & '_' & ethnicity_id & '_' & gender_id as enrollment_key 
   RESIDENT [temp_link_table] 
   

5. cadere il vostro tabelle temporanee in modo che non compaiono nel vostro modello di dati:

   DROP TABLE [temp_test_scores]; 
   DROP TABLE [temp_enrollment]; 
   DROP TABLE [temp_link_table]; 
   

Questa operazione rimuoverà tutte le associazioni tra le tabelle dei fatti poiché non esiste alcun nome di campo comune tra di esse. Ogni tabella dei fatti si collegherà alla tabella dei collegamenti tramite la chiave concatenata creata. La tabella dei collegamenti verrà quindi associata a ogni singola tabella di ricerca. Il modello di dati di Qlikview non conterrà chiavi sintetiche o riferimenti circolari.

Se si crea un'altra tabella dei fatti in futuro, basta seguire nuovamente i passaggi 1 & 2 e aggiungere eventuali nuove chiavi individuali alla Tabella collegamenti e aggiungere anche la nuova chiave concatenata alla Tabella collegamenti. Scala con poco sforzo.

Buona fortuna!

Answer 2

I due modi più veloci mi viene in mente:

A) Si può solo lasciato unirsi alla tabella dei fatti nelle tabelle corrispondenti che sono utilizzati in Appena sarà necessario rinominare. i campi per evitare conflitti con le altre tabelle.

B) È possibile rinominare i campi comuni, che può essere fatto da

1. utilizzando un QUALIFY (prima di caricare le tabelle dei fatti) e UNQUALIFY (dopo aver caricato le tabelle dei fatti)
2. ridenominazione il campo usando "[Nome campo vecchio] come [Nuovo nome campo]"

Supponendo che le tabelle dei fatti abbiano nomi di campi ID univoci che possono essere collegati alle tabelle principali, non si dovrebbe dovere rinominare nulla in il principale tavoli

Vorrei andare con B-1, dal momento che sembra un po 'meno di una seccatura.

QUALIFY 
A, 
B, 
C, 
ID; 

FactTable1: 
Load ID, 
A, 
B, 
C, 
From [FactTable1]; 

FactTable2: 
Load ID, 
A, 
B, 
C, 
From [FactTable2]; 

UNQUALIFY 
A, 
B, 
C, 
ID; 

EDIT: Se si desidera creare una tabella di collegamento a questi, è possibile concatenare le tabelle dei fatti in una tabella dove si mettono tutte le colonne in esso (ci saranno nulli per un sacco di colonne, ma QlikView è valido con valori null).

Quello che faccio di solito è caricare le tabelle dei fatti e creare un campo id (o RowNo() o autonumberhash128 ([elenco dei nomi dei campi id univoco]), quindi quando li carico in una tabella dei collegamenti, includo quell'id Infine, ho eliminato tutti i campi comuni dalle tabelle dei fatti, quindi esistono solo nella tabella dei link.

Answer 3

Tuttavia, ogni tabella dei fatti ha un sottoinsieme diverso di "condivisa". "campi, quindi non sarei in grado di inserire correttamente le mie tabelle dei fatti.

Uno degli ingressi alla vostra dimensione cartesiano sarebbe 'N/A' contro il Soggetto e codice di prova (dal momento che non è nella tabella iscrizioni)

Quindi, quando si misura da 'di genere' Test I punteggi corrispondono ai record delle dimensioni con Codici di verifica e soggetti validi e Corrispondenze di iscrizione rispetto ai record con Soggetti e codici di test

Quindi, quando si esegue il rollup di Gender, tutto funziona "correttamente".

Answer 4

Esistono due strategie principali per i dati di modellazione in QlikView per gestire più tabelle dei fatti:

1. accodare le vostre tabelle dei fatti in una sola tabella dei fatti - di solito di cui come un fatto concatenati come la sintassi di QlikView per aggiungendo i dati di tabelle è con l'uso del prefisso CONCATENA (la equivalente di un'operazione di SQL UNION)

2. Costruire una tabella di collegamento (quello che avete fatto finora) per la maggioranza dei implementazioni, l'opzione 1 è il metodo appropriato. Gli attributi di un fatto concatenato possono essere così riassunti:

positivi:

1. si comporta bene a causa del ridotto numero di tabelle di grandi dimensioni nel modello di dati
2. semplice da implementare, basta aggiungere tutti i dati in una tabella dei fatti generica pur assicurando che le dimensioni comuni siano referenziate da nomi di campo comuni

negativi:

1. I diversi fatti NON sono direttamente associati l'uno con l'altro. L'implicazione è importante per capire. Significa che l'analisi incrociata dei fatti è tipicamente raggiungibile solo dalle dimensioni comuni. Qualsiasi dimensione specifica del fatto non si collega in alcun modo alle registrazioni dei fatti che non fanno riferimento a queste dimensioni. La sintassi complessa "set analysis" può in una certa misura mitigare questa lacuna, ma se il tuo requisito principale è quello di fare un'analisi indiretta del fatto A di fatto con le dimensioni specifiche dei fatti di B allora potresti aver bisogno di ripristinare un modello di tabella di collegamento.

Come costruire le tabelle di collegamento è un argomento complesso ma fa affidamento sulle tradizionali tecniche di progettazione di tabelle di collegamento del database. È facile sbagliare e produrre tabelle di collegamento che potrebbero sembrare produrre i risultati corretti nel front-end, ma è eccessivamente grande, consumando risorse di memoria e CPU.

Secondo la mia esperienza, un modello di dati QlikView modellato male è il colpevole più comune per causare prestazioni scadenti.

Spero che questa introduzione rapida e approfondita alla modellazione multi-fact in QlikView si riveli un aiuto e ti metta sulla giusta rotta.