Combien de colonnes est trop de colonnes?
J'ai remarqué que beaucoup de gens ici citent des tables avec plus de 20 colonnes (j'ai vu jusqu'à 55) dans une table. Maintenant, je ne prétends pas être un expert en conception de bases de données, mais j'ai toujours entendu dire que c'était une pratique horrible. Lorsque je vois cela, je suggère généralement de diviser en deux tableaux avec une relation un à un: l'un contenant les données les plus fréquemment utilisées, l'autre avec les données les moins souvent utilisées. Bien qu'en même temps, il y a le problème possible de performance (moins de JOIN et autres). Voici donc ma question:
En ce qui concerne les bases de données à très grande échelle, y a-t-il réellement un avantage à avoir un grand nombre de colonnes, malgré le fait que cela conduit généralement à de nombreuses valeurs NULL?
Quel est le résultat le plus important: beaucoup de colonnes avec beaucoup de NULL ou moins de colonnes avec beaucoup de JOIN?
La conception de la table dépend de l'entité qu'elle doit stocker. Si toutes les données appartiennent ensemble, alors 50 colonnes (ou même 100) pourraient être la bonne chose à faire.
Tant que la table est normalisée , il n'y a pas de règle empirique concernant la taille, à part les capacités de la base de données et la nécessité d'optimiser.
Je suis d'accord avec Oded. J'ai vu des tableaux contenant 500 colonnes, et toutes les colonnes étaient au bon endroit. Considérez simplement le nombre de faits que vous pourriez souhaiter stocker sur un objet de tous les jours, et vous comprendrez bientôt pourquoi.
S'il s'avère peu pratique de sélectionner toutes ces colonnes ou de spécifier les colonnes à sélectionner lorsque vous n'êtes intéressé que par une petite partie d'entre elles, il peut être utile de définir une vue.
Combien de colonnes est trop de colonnes?
Lorsque vous pensez que cela n'a plus de sens ou qu'il est juste d'ajouter une autre colonne.
Dépend généralement de l'application.
odbc a une limite de caractères de 8000 .... c'est donc une limite physique au-delà de laquelle les choses deviennent très frustrantes.
J'ai travaillé sur une table qui avait 138 colonnes .. elle était horriblement écrite et aurait pu être normalisée. Bien que cette base de données semble avoir été la création de quelqu'un se demandant pourquoi il existe des conventions dans la conception de la base de données et décidant de les tester toutes en même temps.
Avoir des tables aplaties très larges est assez courant lorsque vous entrez dans des serveurs d'entreposage de données et de rapports. Ils sont juste beaucoup plus rapides et signifient que vous n'avez pas à stocker l'intégralité de votre base de données dans RAM pour des performances.
Avoir trop de colonnes entraîne beaucoup de null (mauvais) et un objet encombrant auquel la table est mappée. Cela nuit à la lisibilité dans le IDE et entrave la maintenance (augmentation des coûts de développement). Si vous avez besoin de lectures rapides dans certains cas, utilisez des tableaux dénormalisés, par exemple utilisés uniquement pour les rapports ou les requêtes (recherchez le modèle "CQRS"). Oui. "Personne" a un million d'attributs, mais vous pouvez décomposer ces tables monothiliques (la conception précède la normalisation) pour correspondre à des entités plus petites ("adresse", "téléphone", "hobby") au lieu d'ajouter de nouvelles colonnes pour chaque nouvelle utilisation Le fait d'avoir des objets (et des tables) de plus petite taille offre de nombreux avantages; ils permettent des choses comme les tests unitaires, la POO et les pratiques SOLID.
De plus, en ce qui concerne le regroupement de nombreuses colonnes pour éviter les jointures, je pense que le gain de performances en évitant les jointures est perdu par la maintenance d'index, en supposant une charge de travail typique à la fois en lecture et en écriture. L'ajout d'index sur les champs pour améliorer les performances de lecture pourrait indiquer la nécessité de déplacer ces champs dans leur propre table.
D'après mon expérience, il est préférable d'avoir moins de jointures car celles-ci ont tendance à se produire trop souvent, en particulier dans les grandes bases de données. Tant que vos tables de base de données sont conçues pour stocker une seule entité (étudiant, enseignant, etc.), cela devrait être correct. Pour que cela soit représenté comme un objet dans votre code plus tard. Donc, si vous divisez l'entité en plusieurs tables, vous devrez utiliser plusieurs jointures afin de remplir votre objet plus tard. De plus, si vous utilisez ORM pour générer votre couche d'accès aux données (comme Linq dans .Net), cela générera des classes distinctes pour chaque table (bien sûr avec une relation entre elles, mais quand même) et cela sera plus difficile à utiliser.
Une autre chose est que vous pouvez spécifier les colonnes à renvoyer dans votre requête, ce qui réduira les données transmises à votre application, mais si vous avez besoin d'une seule colonne d'une autre table, vous devrez effectuer la jointure. Et dans la plupart des cas, comme vous avez autant de colonnes, la probabilité d'avoir une grande quantité de données stockées dans la base de données est élevée. Donc, cette jointure nuirait plus que les NULLs.
Chaque projet sur lequel j'ai travaillé est différent, vous devriez donc trouver l'équilibre pour chaque histoire.
Quel est le résultat le plus important: beaucoup de colonnes avec beaucoup de NULL ou moins de colonnes avec beaucoup de JOIN?
Cela dépend uniquement des données que vous stockez, des index que vous créez, etc. Personne ne peut vous assurer que l'un fonctionne mieux qu'un autre sans savoir ce que vous stockez. En règle générale, les règles de normalisation vous "forceront" à séparer les données de différentes tables et de FKeys utilisateur si vous avez une grande table, mais je ne suis pas d'accord qu'elle fonctionne TOUJOURS mieux qu'une grande table. Vous pouvez terminer avec des jointures de niveau 6-7 dans des dizaines de requêtes qui peuvent parfois provoquer des erreurs, car il y a beaucoup plus de chances de créer une erreur dans les requêtes plus importantes que dans les requêtes simples.
Si vous postez certaines exigences de ce que vous faites, nous pouvons peut-être vous aider à concevoir correctement la base de données.
Cela dépend également fortement du cas d'utilisation de votre table. Si vous souhaitez l'optimiser pour la lecture, il peut être judicieux de tout regrouper dans une seule table.
Dans le monde NO-SQL (cassandra/hbase par exemple), il n'y a pas de contraintes sur le nombre de colonnes et il est en fait considéré comme une bonne pratique d'avoir plusieurs colonnes. Cela vient également de la façon dont il est stocké (pas de lacunes). Ça vaut la peine d'enquêter.