Perguntas[normalization](dba)

Suponha que tenhamos uma relação R(A, B, C) com o FD A -> B. Digamos que, para duas tuplas t e u em R, se t[C] e u[C] satisfazem uma condição booleana - digamos menos que uma constante C - então t[B] = u[B]. Isso constitui uma dependência funcional?

Em um sentido mais prático, como normalizar essa relação e eliminar a redundância clara em R(A, B, C) e permitir junções sem perdas?

Eu tenho uma tabela e devo descobrir por que ela quebra com 1NF, 2NF e/ou 3NF. Conheço as diferenças entre esses três, mas sou ruim em dizer quais atributos são chaves primárias e o que depende de quê. Alguém pode explicar isso em termos de bebê? Eu sou novo em todo o reino de banco de dados.

Aqui está a tabela:

Auditorium (title of the table)

ACodeID  NrSeats  Projector  PC  Uni  UniAdr  UniPhone

Explicação para cada atributo:

ACodeID= Código único para cada auditório.

NrSeats= Número de lugares no auditório.

Projector= Se o auditório tem ou não projetor.

PC= Se o auditório tem ou não um computador.

Uni= Em qual universidade o auditório está localizado.

UniAdr= Endereço da universidade.

UniPhone= O número de telefone da universidade (cada universidade tem apenas um número de telefone neste exemplo).

Além disso, alguma idéia de como posso separar esta tabela em outras separadas para que as novas tabelas atendam à 3NF?

Obrigado!

Esta é uma pergunta de um livro didático

Consider the Relation R={A, B, C, D, E, F, G, H } and the set of functional dependencies.
A→C B→CG AD→EH C→DF A→H
What is the key for R? Decompose R into 2NF, 3NF and finally in BCNF relation

Eu acredito que A Bsão a chave do candidato.

Eu decompus R para 2nf assim:

R1={A,C,H,D,F,E,H}
R2={B,C,G,D,G,F}
R3={A,B}

Para 3nf:

R1A={A,C,H}
R1B={C,D,F}
R2={B,C,G}
R3={A,B}
R4={A,D,E}

Meu problema

Isso claramente não parece certo, pois ainda temos várias anomalias e nenhuma relação para converter para bcnf. Como devo normalizar corretamente o R

Estou integrando com serviços que usam OAuth, e os dados que preciso salvar no banco de dados são muito semelhantes. No entanto, existem pequenas diferenças com as duas primeiras implementações.

Ambos têm um token, expiração, refreshToken e refreshTokenExpiration. No entanto, um tem um "realmId" e o outro tem um "redirectUri" que precisa ser salvo com ele.

Do jeito que eu vejo, eu tenho 3 opções:

a) Adicione realmId e redirectUri à mesma tabela e um será preenchido e o outro nulo, dependendo de qual serviço está sendo usado. Claro, quem sabe se eu terei que continuar adicionando colunas adicionais à medida que mais serviços são adicionados com requisitos diferentes?

b) Normalize os dados de forma que haja uma tabela para os dados semelhantes, mas tabelas separadas que contenham os dados exclusivos para cada serviço e tenham chaves estrangeiras para a tabela com os dados de token semelhantes.

c) Nem se preocupe em tentar armazenar os dados semelhantes em uma única tabela. Mas sim crie uma tabela completamente separada para cada serviço.

Sendo mais pragmático do que ideólogo, estou inclinado para c). Uma razão adicional para isso é que um serviço concede tokens com base em contas, enquanto o outro serviço concede tokens com base em usuários que podem estar em várias contas.

Eu sei que este é certamente um problema comum, mas eu simplesmente não sei como descrever o problema de forma que eu possa encontrar informações úteis sobre ele em minhas pesquisas.

Atualmente, estou armazenando transações financeiras na tabela a seguir (abreviada para resumir):

id INT
start DATETIME
end DATETIME
rate INT
usage INT
usage_fee INT
amount INT
commission_pct INT
payout INT
currency VARCHAR(5)

O valor total cobrado de um cliente é calculado da seguinte forma: amount = (end - start) * rate + usage * usage_fee

A plataforma cobra uma taxa/comissão de: commission = amount * (commission_pct / 100)

O pagamento que o provedor de serviços recebe é: payout = amount - commission

Agora, na tabela acima, armazenar o pagamento é tecnicamente redundante, pois pode ser calculado conforme mostrado acima. Minha pergunta é: qual é a maneira/convenção comum de armazenar esses tipos de transações financeiras em relação à redundância de dados?

Por exemplo, estou pensando em armazenar também o resultado de (end - start) * ratee usage * usage_feeseparadamente nesta tabela, além de sua soma (quantidade).

Os prós que vejo de fazer isso são:

• sem erros (de arredondamento) ao enviar os respectivos valores para a "API do provedor de pagamento", ou seja, o que o usuário acaba pagando é exatamente o mesmo que está armazenado no banco de dados ao invés de enviar valores computados para a referida API
• consultas e análises fáceis

Esses prós são válidos ou você me recomendaria normalizar completamente a tabela e calcular os valores sempre que necessário?

Eu sei que normalizar a tabela é a resposta correta de acordo com "princípios de design de banco de dados", mas como estou lidando com dados financeiros, não tenho certeza se estou 100% confortável usando valores calculados.

A taxa de comissão não é específica por transação, mas o commission_pct cobrado provavelmente mudará no futuro e, portanto, é armazenado junto com cada transação. É claro que não seria necessário armazenar a porcentagem da comissão se o "valor da comissão" real for armazenado.

A comissão_pct e a taxa usada naquele momento são armazenadas na tabela, e é por isso que alterá-las no futuro para transações subsequentes não é um problema e as transações existentes nunca serão editadas. Além disso, há apenas um aplicativo controlado que tem acesso ao banco de dados. Se a fórmula mudar no futuro, não ter os resultados computados e armazenados seria um problema. Estou inclinado para o aplicativo que calcula esses valores e armazena os valores "brutos" e calculados de uma só vez.

USER(userID, email, nome, endereço, ...)

ID do usuário

• chave primária
• incrementando bigint

o email

• identificador único
• pode ser modificado pelo usuário

Para mim isso parecia uma boa ideia, mas então comecei a me perguntar: a singularidade do 'email' viola a terceira forma normal (3NF)?

Resumidamente, quais são as principais vantagens e desvantagens da normalização como técnica de projeto de banco de dados?

Pode ser mais fácil responder a isso com um instantâneo de alguns dados não organizados, como um exemplo concreto:

Estou tendo problemas para identificar a combinação de atributos que compõem as Dependências Funcionais (FDs) de uma determinada tabela. Embora eu entenda como o processo de normalização funciona quando recebe os FDs, não consigo traduzir e identificar FDs para uma determinada tabela.

Fui encarregado de criar um banco de dados de uma empresa que rastreie todas as despesas de vendas/pacotes etc. Naturalmente isso significa armazenar informações de clientes para a empresa identificar todos os consumidores.

CREATE TABLE Customers (
    id        integer primary key,
    address   text not null,
    name      text not null,
    email     text unique not null,
    phone     text unique not null,
    unique(name, address)
);
    

Optei por representar as informações da tabela de clientes como tal, já que cada número de telefone e e-mail está vinculado exclusivamente ao cliente. A restrição exclusiva permite que várias pessoas do mesmo endereço residencial estejam presentes na tabela.

Quero ver se consigo normalizar ainda mais essa tabela, porém não consigo identificar os atributos para determinar os FDs necessários.

Faz muito tempo que não estudei design relacional, mas tinha uma vaga lembrança de que isso me incentivava a não dividir uma tabela desnecessariamente. Por exemplo, dadas as dependências funcionais

K -> A
K -> B
K -> C

minha suposição era que o "melhor" esquema é justo {KABC}e não algo como {KAB, KC}ou mesmo {KA, KB, KC}. Pelo menos na prática é assim que eu vi os designers de banco de dados implementarem a tabela.

No entanto, uma rápida atualização na Wikipedia indica que o formalismo de normalização

• não faz nenhuma declaração no sentido de obter um "esquema mínimo",
• 6NF exigiria mesmo {KA, KB, KC}. Uma vez que 6NF implica as outras formas normais, isso implica que é mesmo impossível para eles fazerem um requisito mínimo.

Estou um pouco confuso que eu tenho isso errado o tempo todo. A noção de "obter um número mínimo de tabelas" realmente não desempenha nenhum papel no design relacional formal e é apenas uma prática comum?

Então, estou fazendo uma tarefa em que pego uma lista enorme (mais de 30.000) de filmes na Wikipedia que têm várias colunas (como o nome do filme, o gênero, o elenco, o enredo etc.) e carrego no Elasticsearch. No entanto, depois de fazer isso, agora quero fazer com que a tabela esteja em pelo menos 1NF. Não tenho muita experiência em design de banco de dados e a última vez que fiz algo com o Normal Form foi há alguns anos. Então eu estou olhando para esta tabela e pensando, como eu poderia colocar isso no 1NF. É fácil se, por exemplo, houver apenas 1 coluna com vários valores, mas o que você faz quando há várias colunas com vários valores, como visto abaixo.

Você teria que fazer algo assim...

etc? Certamente estou perdendo algo extremamente simples quando se trata de converter uma tabela com várias células com vários valores em 1NF, mas não tenho certeza do quê.

Obrigado.