Este é o esquema com o qual estou trabalhando:

Aqui está o DBML para recriar em https://dbdiagram.io/d :

Table University {
  ID integer [primary key]
}

Table Professor {
  ID integer [primary key]
  UniversityID integer [primary key, ref: > University.ID]
}

Table Class {
  ID integer [primary key]
  UniversityID integer [primary key, ref: > University.ID]
  ProfessorID integer [null]
}

Ref: Class.(ProfessorID, UniversityID) - Professor.(ID, UniversityID)

Meu objetivo:

• Uma universidade pode ter várias turmas e professores.
• Uma classe pode ter um ou nenhum professor.
• A exclusão de uma universidade exclui todos os seus professores e turmas
• Excluir um Professor define Class.ProfessorID como NULL

O último objetivo está nos causando problemas. O SQL Server impede a adição de outra restrição de chave estrangeira em cascata devido a múltiplos caminhos em cascata, e um gatilho não pode funcionar porque:

1. a consulta de exclusão é rejeitada devido à restrição de chave estrangeira no Professor, portanto, um gatilho FOR DELETE nunca será executado
2. O SQL não pode criar um INSTEAD OF DELETE devido ao relacionamento em cascata com a Universidade

Como posso conseguir isso?

No livro que estou lendo atualmente, esta tabela é mencionada como um exemplo do que podemos fazer se uma tabela atende ao BCNF, mas ainda tem redundâncias. Em seguida, menciona que uma solução são matrizes. Mas essa tabela está mesmo no BCNF? Não há dependências funcionais de Language -> PersNr e de Programming -> PersNr. Ambos os atributos não são superchaves, pois não identificam as linhas de forma única. Então, eles quebram o BCNF na minha visão. Ou estou entendendo errado alguma coisa?

Estou procurando projetar um aplicativo (Python com sqlite) que lide com alguns colaboradores que se movem entre vários grupos ao longo do tempo.

Meu design atualmente se parece com (PK em negrito, FK em itálico, ambos se um FK fizer parte do PK):

• Grupo( Id , Nome)
• Contribuidor ( ID , Nome, Primeiro Nome)
• Ação( ActionId , Nome)
• ContributorAction ( ContributorId , ActionId , Data)
• Associação ( GroupId , ContributorId , StartDate , EndDate )

Meu objetivo é manter um histórico de associações para recuperar o grupo de associação correto de um colaborador no momento de uma determinada contribuição.

Fazer isso envolve o uso de colunas de data em uma chave primária (tabela Membership). No entanto, EndDatepode ser NULLpara a associação atual de um colaborador, e eu li que isso pode não ser uma prática boa (ou mesmo permitida).

Perdi alguma coisa aqui para obter pelo menos o design 3NF?

Exposição

Digamos que nosso sistema tenha usuários e alguns jogos . Vamos chamar esses jogos de A , B e C.

Para simplificar, nossas tabelas iniciais ficam assim:

CREATE TABLE IF NOT EXISTS users (
    id SERIAL PRIMARY KEY
);

CREATE TABLE IF NOT EXISTS games (
    id SERIAL PRIMARY KEY
);

Problema

Sempre que jogamos esses jogos e os terminamos, temos que registrar estatísticas relacionadas ao jogo para o usuário específico. Por exemplo, para o jogo A, temos que registrar total_jumps e total_crouches porque a mecânica do jogo permite tal acumulação, no entanto, os jogos B e C podem exigir que registremos outros campos total_* (embora o prefixo total_ não seja necessário). Como armazeno essas informações?

Estou preocupado com a solução para esse problema. Eu criei 2 abordagens:

Solução 1

Tenha uma única tabela para isso:

CREATE TABLE IF NOT EXISTS statistics (
    user_id SERIAL REFERENCES users (id) ON DELETE CASCADE,
    game_id SERIAL REFERENCES games (id) ON DELETE CASCADE,
    fields JSONB,
    PRIMARY KEY (user_id, game_id)
);

Dessa forma, deixamos para o nível do aplicativo analisar dados arbitrários provenientes da coluna de campos .

Solução 2

Tenha várias mesas, uma para cada jogo:

CREATE TABLE IF NOT EXISTS A_statistics (
    user_id SERIAL PRIMARY KEY REFERENCES users (id) ON DELETE CASCADE,
    total_jumps INTEGER,
    total_crouches INTEGER
);

Pessoalmente, a solução #2 parece melhor para mim, mas... esse problema ainda me incomoda muito. Como se eu estivesse esquecendo de algo, porque nenhuma das opções torna a extensão (adicionar novos jogos) mais fácil? Digamos que adicionamos os jogos D , E e F . Ambas as soluções exigem que, de alguma forma, manipulemos campos específicos (no nível do aplicativo) necessários para esses jogos. Isso é algo com o qual eu simplesmente tenho que me conformar? Ou há uma terceira solução melhor para isso que eu simplesmente não vejo?

Tenho lido sobre os índices columnstore do Microsoft SQL Server recentemente e fiquei preocupado que minha experiência não corresponda à do setor. Os índices columnstore são projetados para tornar os agregados fáceis. É dito com muita frequência que, por esse motivo, eles são ideais para tabelas de fatos.

Isso me deixa desconfortável. Na minha experiência, tabelas de fatos não são agregadas . A lista de colunas para cada tabela de fatos que já fiz tem o formato "chave primária seguida por várias colunas de dimensão, seguidas por cada bit de informação que armazenamos sobre a chave primária". Elas então são despejadas em alguma ferramenta de BI como PowerBI ou ThoughtSpot, para que pessoas não técnicas possam filtrar com base nas dimensões e descobrir o que quiserem saber. Elas podem agregar de tempos em tempos, mas esse certamente não é o uso principal da tabela. Espero que essas tabelas tenham bem mais de 100 colunas.

O design da tabela e o padrão de acesso que estou descrevendo são o que se espera de uma tabela de fatos? Ou estou descrevendo um tipo de tabela totalmente diferente, cujo nome desconheço?

Agora estou criando um BD de sistema bancário que é mais conveniente no caso da entidade de conta para torná-la a chave primária composta de chaves estrangeiras (id da agência, id do cliente, id do serviço, quatro inteiros gerados para exclusividade) para serviço de contexto como empréstimo etc., ou torná-los apenas chaves estrangeiras normais. Se você puder fornecer um caso mais geral em que a chave composta seja o melhor caso de uso

Eu e meu amigo estamos criando um diagrama ER para uma liga profissional de futebol. Somos muito novos em banco de dados, então não temos certeza se tudo o que fazemos está correto.

Ao criar um relacionamento entre um gerente e um clube, ele fez isso:

Estou bastante confuso sobre o porquê dos 2 relacionamentos managedBy e signsWith serem Muitos para Muitos. Meu amigo disse que vários gerentes podem gerenciar vários clubes, um para um de cada vez. Mas não deveria ser Um para Um? Já que a qualquer momento, um clube só pode ter um único gerente gerenciando-o e um gerente só pode ter um único clube para gerenciar (não nos importamos com o gerente assistente neste caso); a mesma coisa sobre o relacionamento signsWith.

Então, qual de nós está certo?

Por que tantas pessoas preferem bancos de dados colunares? No meu entender, as pessoas preferem bancos de dados colunares porque são mais rápidos para consultas devido ao fato de que a CPU seria capaz de armazenar em cache os próximos valores de forma previsível.

Atualmente tenho uma entidade Ticket , agora pretendo criar outra entidade chamada TicketHistory assim como a imagem abaixo para acompanhar as alterações que aconteceram na entidade Ticket , gostaria de saber se essa é a maneira "correta" de projetar este caso?

Como criar um id único no Flutter para adicionar ao banco de dados no firebase?