Che cosa sta combinando serie ripetute di informazioni di riga in nuove quadro chiamate durante la normalizzazione del database?

Sono un po ‘confuso su un certo pezzo di normalizzazione del database e ho pensato di chiedere a StackOverflow:

Immagina di avere le seguenti relazioni che mettono in relazione i prodotti con i colors. Si noti che Prodotto 1 e Prodotto 2 utilizzano entrambi lo stesso set di colors (blu e verde).

Product_Color Color +-------------+-------------+ +-------------+-------------+ | Product* | Color* | | ColorId* | Name | +-------------+-------------+ +-------------+-------------+ | 1 | 1 | | 1 | Blue | | 1 | 2 | | 2 | Green | | 2 | 1 | +-------------+-------------+ | 2 | 2 | +-------------+-------------+ 

Se creo due nuove relazioni, ColorSet e ColorSet_Color, posso visualizzare le stesse informazioni unendo insieme le 4 relazioni.

 Product_ColorSet: ColorSet_Color: +-------------+-------------+ +-------------+-------------+ | Product* | ColorSetId* | | ColorSetId* | ColorId* | +---------------------------+ +-------------+-------------+ | 1 | 1 | | 1 | 1 | | 2 | 1 | | 1 | 2 | +-------------+-------------+ +---------- --+-------------+ ColorSet: Color: +-------------+ +-------------+-------------+ | ColorSetId* | | ColorId* | Name | +-------------+ +-------------+-------------+ | 1 | | 1 | Blue | | 2 | | 2 | Green | +-------------+ +----------[--+-------------+ 

A questo punto, se avessi una grande tabella Product_Color, con un ragionevole grado di gruppi di colors condivisi, sarei in grado di guadagnare considerevolmente da una prospettiva spaziale.

Qual è il nome tecnico per questa operazione nel contesto della normalizzazione del database? Sto chiaramente rimuovendo le informazioni ridondanti anche se l’ quadro che ho creato non esiste realmente, è piuttosto più casuale che ci sono molte sovrapposizioni. Cosa sto specificatamente modificando facendo questo?

Inoltre, sembra che potrei farlo arbitrariamente alla maggior parte delle entity framework. Ciò che mi lascia perplesso è che Product_Color e Color sono già in sesta forma normale quando abbiamo iniziato l’esercizio (giusto?).

Stai introducendo una ” chiave surrogata ” (o identificatore) per nominare / identificare i gruppi di colors in cui i prodotti entrano. L’alternativa è solitamente considerata una ” chiave naturale ” (o identificatore). (Anche se diverse persone usano questi termini in modo diverso nei dettagli, ad esempio alcuni potrebbero usare “surrogato” solo quando un nome / identificatore è assegnato a un referente in modo permanente e / o è l’unico nome / identificatore del suo referente e / o è visibile solo con il database e non certo l’applicazione, ad esempio alcuni direbbero che un nome / identificatore arbitrario generato dal sistema visibile esternamente come un numero identificativo del conducente è sia un surrogato che naturale).

Le chiavi surrogate sono spesso chiamate “senza significato (identificatori)”. Questo riflette il pensiero confuso. Tutti i nomi non generati da uno schema di denominazione a priori sono “privi di significato” e arbitrari. “Nicholas” non ha “significato” te fino a quando non è stato scelto; essendo stato scelto, significa “voi”. Questo vale per qualsiasi nome / identificatore. Quindi “senza significato” / “significativo” non è una distinzione utile. Un nome / identificatore surrogato in un sistema è solo uno che è stato scelto dopo l’avvio del sistema. Ciò che viene chiamato “significativo” [sic] in un sistema sarebbe stato chiamato “privo di significato” [sic] quando assegnato in qualsiasi sistema esistesse prima (dato che l’incarico era dopo che era iniziato).

Esiste una “prospettiva” in cui si “rimuovono le informazioni ridondanti”, ma non è il tipo di ridondanza a cui si riferisce la normalizzazione. Stai sostituendo una tabella con altre tabelle, ma non è la decomposizione della normalizzazione. L’introduzione di surrogati non fa parte della normalizzazione. La normalizzazione non introduce nuovi nomi di colonne. Riutilizza solo i nomi di una tabella originale nelle tabelle che la sostituiscono. (Sei in grado di descrivere chiaramente ed esattamente cosa intendi per “ridondante” qui?)

A volte le persone pensano che se la stessa sottotipo di valori può apparire più di una volta in un set di colonne o in una tabella, allora i valori di subrow devono essere sostituiti da id che sono FK in una nuova tabella che associa i valori di id ai valori di subrow. (Forse anche per le sottogruppi a colonna singola, vale a dire quando un singolo valore appare più di una volta in una colonna o tabella.) Pensano che le apparizioni multiple di valori di sottotitoli siano “ridondanti” o che solo gli ID possano essere ripetuti senza essere “ridondanti”. (Il design dell’ID è visto come una sorta di compressione dei dati dell’originale.) Potrebbero pensare che questo sia parte della normalizzazione. Niente di tutto ciò è così.

Questa non è ridondanza che dovresti preoccuparti di affrontare tramite il design del tavolo. Se conoscete le opzioni di implementazione delle vostre tabelle da parte del DBMS e conoscete i modelli di utilizzo della vostra applicazione e sapete che l’originale è dimostrabile e significativamente peggiore di qualche opzione che risulta essere “meno ridondante” (e perché non dovrebbe l’opzione “più ridondante” è migliore?) allora dovresti dire al DBMS quale opzione vuoi per la tua progettazione senza modificare lo schema se puoi. (Questo è tipicamente fatto tramite indici e / o viste.) Ad esempio, l’indicizzazione del tuo prodotto ProductColor su ColorId porta essenzialmente alla stessa struttura dell’implementazione che hai creato a mano nel tuo secondo progetto, ma generata e gestita automaticamente. (Si potrebbero introdurre surrogati per altri motivi, ad esempio per sostituire le chiavi esterne a più colonne con valori più concisi, anche se più oscuramente valutati e vincolati.)

Re opzioni: il nuovo design utilizzerà più operazioni (ad esempio join e proiezioni) nel testo della query e (per le tipiche implementazioni DBMS) rispetto all’originale (ad esempio per eseguire query sulla tabella originale) ma meno altrove (ad esempio, nella copia del set di colors di un prodotto a un altro). Quindi, ancora una volta si tratta di scambi di molteplici “prospettive”.

In effetti, in un altro senso hai introdotto la ridondanza con i surrogati. Ci sono colonne aggiuntive che contengono un gruppo di valori di identificazione che non sono ancora nell’originale e registrano le stesse situazioni. Hai anche appesantito l’utente con un design con più nomi e riferimenti indiretti. Il design surrogato ha sicuramente molte “informazioni ridondanti” in questa “prospettiva” rispetto all’originale.

Anche il tuo progetto iniziale ha probabilmente introdotto surrogati, ovvero identificatori di colore di nomi di colors. (Se i colors identificativi aggiungessero “informazioni”, cioè “informati” oltre i loro nomi associati, allora non sarebbero surrogati e sarebbero necessari). Cioè se i colors sono scelti arbitrariamente, si potrebbe semplicemente avere:

 Product_Color +-------------+-------------+ | Product* | ColorName* | +-------------+-------------+ | 1 | Blue | | 1 | Green | | 2 | Blue | | 2 | Green | +-------------+-------------+ 

Dovresti avere una ragione per introdurre id colore e, per questo, id prodotto, piuttosto che chiavi naturali già esistenti. Puoi giustificare più tabelle, nomi e riferimenti indiretti rispetto a uno solo?