SQL: utilisation de valeurs NULL et de valeurs par défaut
Quels sont les pros _ et contre__ de l'utilisation de valeurs NULL en SQL par opposition à valeurs par défaut?
PS. Beaucoup de questions similaires ont été posées ici mais aucune ne répond à ma question.
Une valeur NULL dans les bases de données est un système valeur qui occupe un octet de storage et indique qu’une valeur est non présent par opposition à un espace ou zéro ou toute autre valeur par défaut. Le champ dans une base de données contenant le La valeur NULL signifie que le contenu de cette cellule est inconnue à l'époque de en le regardant. Une colonne qui permet Les valeurs NULL permettent également aux lignes d'être inséré sans aucune valeur dans cela colonne. Il y a plusieurs avantages et Inconvénients de l’utilisation des valeurs NULL par opposition à aux valeurs par défaut:
Avantages
La valeur NULL ne contient pas les données type, peut donc être inséré dans n’importe quel fichier structure de données et toute base de données colonne. Les valeurs par défaut, d'autre part main, besoin d'avoir leur type de données spécifié et une valeur par défaut dans un la colonne pourrait se ressembler dans un autre colonne, mais il pourrait être d'un différent type.
NULL est souvent utilisé dans les schémas où un la valeur est facultative. C'est une pratique méthode pour omettre la saisie de données pour champs inconnus sans avoir à implémenter des règles supplémentaires, comme stocker des valeurs négatives dans un entier champ pour représenter les données omises.
Puisque la valeur NULL ne prend que 1 peu d’espace mémoire, ils peuvent être utile lors de l'optimisation de la base de données . Utiliser ces valeurs, c'est beaucoup plus efficace que les valeurs par défaut, par exemple . 8 bits du caractère et le nombre entier 16bits.
Alors que vos exigences système peuvent changer au fil du temps et la valeur par défaut types avec eux, la valeur NULL est toujours NULL, il n'est donc pas nécessaire de mettre à jour le fichier type de données.
Affectation de Not Null à des schémas de table peut également aider à la validation de la table, dans un sens que la colonne avec Not Les critères nuls nécessiteront une valeur de être inséré. Les valeurs par défaut ne le font pas avoir ces capacités.
Les inconvénients
Les valeurs NULL se confondent facilement avec Chaînes de caractères vides, qui retournent une valeur vide pour l'utilisateur quand choisi. En ce sens, par défaut les valeurs sont moins déroutantes et sont les option plus sûre, sauf la valeur par défaut est défini sur la chaîne vide.
Si les valeurs NULL sont autorisées dans le fichier base de données, ils peuvent provoquer le concepteur un peu plus de temps et de travailler comme ils peuvent rendre plus logique la base de données compliqué, surtout quand il y a beaucoup de comparaisons avec des valeurs nulles dans endroit.
Source: Pro and cons
Je ne sais pas pourquoi vous essayez même de les comparer à des cas. null signifie qu'une colonne est vide/n'a pas de valeur, alors que la valeur par défaut donne une valeur à une colonne lorsque nous ne la définissons pas directement dans une requête.
Peut-être que quelques exemples seront une meilleure explication. Disons que nous avons la table member. Chaque membre a un identifiant et un nom d'utilisateur. Facultatif, il peut avoir une adresse électronique (mais il n'est pas obligé de le faire). De plus, chaque membre a une colonne postCount (qui est augmentée chaque fois que l'utilisateur écrit un post). Ainsi, la colonne e-mail peut avoir une valeur null (parce que l'e-mail est facultatif), tandis que la colonne postCount est NOT NULL mais a la valeur par défaut 0 (car lorsque nous créons un nouveau membre, il n'a aucune publication).
Les valeurs nulles ne sont pas ... des valeurs!
Null signifie "n'a pas de valeur" ... à côté de l'aspect base de données, une dimension importante des variables ou champs non valorisés est qu'il n'est pas possible d'utiliser "=" (ou ">", "<") lors de la comparaison de variables.
Écrire quelque chose comme (VB):
if myFirstValue = mySecondValue
ne renverra ni Vrai ni Faux si l'une des variables ou les deux ne sont pas valorisées. Vous devrez utiliser un «redressement» tel que:
if (isnull(myFirstValue) and isNull(mySecondValue)) or myFirstValue = mySecondValue
Le code «habituel» utilisé dans de telles circonstances est
if Nz(myFirstValue) = Nz(mySecondValue, defaultValue)
N’est pas strictement correct, car les variables non valorisées seront considérées comme «égales» à la valeur «defaultValue» (généralement une chaîne de longueur nulle).
En dépit de ce comportement désagréable, jamais, jamais activez vos valeurs par défaut en chaîne de longueur nulle (ou '0') sans raison valable, et faciliter la comparaison des valeurs dans le code n'est pas une raison valable.
Les valeurs NULL sont destinées à indiquer que l'attribut est soit non applicable, soit inconnu. Il y a des guerres de religions pour savoir si c'est une bonne ou une mauvaise chose, mais je tombe dans le camp des "bonnes choses".
Ils sont souvent nécessaires pour distinguer les valeurs connues des valeurs inconnues dans de nombreuses situations et rendent inutile une valeur sentinelle pour les attributs ne disposant pas d'une valeur par défaut appropriée.
Par exemple, alors que la valeur par défaut pour un solde bancaire peut être zéro, quelle est la valeur par défaut pour un numéro de téléphone mobile. Vous devrez peut-être faire la distinction entre "le client n'a pas de téléphone portable" et "le numéro de portable du client n'est pas (encore) connu". autre n’est pas une bonne idée).
Les valeurs par défaut sont simplement ce que le SGBD mettra dans une colonne si vous ne le spécifiez pas explicitement.
Pour moi, ils sont un peu orthogonaux.
Les valeurs par défaut vous permettent de faire évoluer gracieusement votre schéma de base de données (pensez à ajouter des colonnes) sans avoir à modifier le code client. De plus, ils économisent un peu de frappe, mais s’appuyer sur les valeurs par défaut est mauvais pour l’OMI.
Les null ne sont que ça: nulls. Valeur manquante et un PITA énorme lorsqu'il s'agit de Logique à trois valeurs .
Comme pour beaucoup de choses, il y a des points positifs et des points négatifs pour chacun.
Les points positifs sur les valeurs par défaut: ils vous permettent de définir une colonne sur une valeur connue si aucune autre valeur n’est donnée. Par exemple, lors de la création de colonnes BOOLEAN, j’attribue généralement à la colonne une valeur par défaut (TRUE ou FALSE, selon le cas) et rend la colonne NOT NULL. De cette façon, je peux être sûr que la colonne aura une valeur et qu'elle sera définie comme il convient.
Points négatifs sur les valeurs par défaut: tout n'a pas de valeur par défaut.
Les points positifs des valeurs NULL: tout n’a pas toujours une valeur connue. Par exemple, lors de la création d'une nouvelle ligne représentant une personne, il se peut que je n'ai pas de valeurs pour toutes les colonnes - disons que je connais leur nom mais pas leur date de naissance. Il n'est pas approprié d'indiquer une valeur par défaut pour la date de naissance - les personnes n'aiment pas recevoir de cartes d'anniversaire le 1er janvier (si c'est la valeur par défaut) si leur date de naissance est réellement le 22 juillet.
Mauvaises choses à propos des valeurs NULL: Les valeurs NULL nécessitent une manipulation minutieuse. Dans la plupart des bases de données construites sur le modèle relationnel, les valeurs NULL couramment implémentées sont un poison - la présence d'une valeur NULL dans un calcul entraîne la valeur NULL du résultat du calcul. Les valeurs NULL utilisées dans les comparaisons peuvent également entraîner des résultats inattendus, car toute comparaison avec NULL renvoie UNKNOWN (qui n'est ni VRAI ni FAUX). Par exemple, considérons le script PL/SQL suivant:
declare
nValue NUMBER;
begin
IF nValue > 0 THEN
dbms_output.put_line('nValue > 0');
ELSE
dbms_output.put_line('nValue <= 0');
END IF;
IF nValue <= 0 THEN
dbms_output.put_line('nValue <= 0');
ELSE
dbms_output.put_line('nValue > 0');
END IF;
end;
La sortie de ce qui précède est:
nValue <= 0
nValue > 0
Cela peut être un peu surprenant. Vous avez un NUMBER (nValue) qui est inférieur ou égal à zéro et supérieur à zéro, du moins selon ce code. Cela s’explique par le fait que nValue est en fait NULL et que toutes les comparaisons avec NULL aboutissent à UNKNOWN au lieu de TRUE ou FALSE. Cela peut entraîner des bugs subtils difficiles à comprendre.
Partager et profiter.
Cela dépend de la situation, mais au final, c'est simple. Lequel est le plus proche de la vérité?
Beaucoup de gens traitent des données comme s'il ne s'agissait que de données et la vérité importait peu. Cependant, chaque fois que vous parlez aux parties prenantes dans les données, vous constatez que la vérité compte toujours. parfois plus, parfois moins, mais cela compte toujours.
Une valeur par défaut est utile lorsque vous pouvez supposer que si l'utilisateur (ou une autre source de données) avait fourni une valeur, celle-ci aurait été la valeur par défaut. Si cette présomption fait plus de mal que de bien, alors NULL est meilleur, même si le traitement de NULL est pénible en SQL.
Notez que les valeurs par défaut peuvent être implémentées de trois manières différentes. Tout d'abord, dans l'application, avant d'insérer de nouvelles données. La base de données ne voit jamais la différence entre une valeur par défaut fournie par l'utilisateur ou une donnée fournie par l'application!
Deuxièmement, en déclarant une valeur par défaut pour la colonne et en laissant les données manquantes dans une insertion.
Troisièmement, en substituant la valeur par défaut au moment de l'extraction, chaque fois qu'un NULL est détecté. Seuls quelques produits de SGBD permettent de déclarer ce troisième mode dans la base de données.
Dans un monde idéal, les données ne manquent jamais. Si vous vous développez dans le monde réel, les données requises seront éventuellement manquantes. Vos applications peuvent soit faire quelque chose de sens ou quelque chose de non sens lorsque cela se produit.
Nulls et les valeurs par défaut sont différentes choses utilisées à des fins différentes. Si vous essayez d'éviter d'utiliser nulls en donnant à tous une valeur par défaut, c'est une mauvaise pratique, comme je l'expliquerai.
Null signifie que nous ne savons pas quelle est la valeur ou sera. Par exemple, supposons que vous ayez un champ enddate. Vous ne savez pas quand le processus en cours d'enregistrement se terminera, alors null est la seule valeur appropriée; utiliser une valeur par défaut d'une fausse date à l'avenir causera autant de problèmes pour programmer que pour manipuler les nulls et est plus susceptible, selon mon expérience, de créer un problème avec le renvoi de résultats incorrects.
Il arrive maintenant que nous sachions quelle doit être la valeur si la personne qui insère le document ne le sait pas. Par exemple, si vous avez un champ date inserted, il est approprié d’avoir une valeur par défaut de la date actuelle et de ne pas attendre que l’utilisateur le remplisse. Vous aurez probablement de meilleures informations pour ce champ.
Parfois, c'est un jugement et dépend des règles métier que vous devez appliquer. Supposons que vous ayez un champ speaker honoraria (qui correspond au montant qu’un orateur serait payé). Une valeur par défaut de 0 pourrait être dangereuse car cela pourrait signifier que des haut-parleurs sont embauchés et que nous avons l'intention de ne rien leur payer. Il est également possible que des orateurs donnent occasionnellement leur temps pour un projet particulier (ou qui sont des employés de la société et ne sont donc pas payés plus que la parole), où zéro est une valeur correcte, vous ne pouvez donc pas utiliser zéro la valeur pour déterminer que vous ne savez pas combien cette enceinte doit être payée. Dans ce cas, Null est la seule valeur appropriée et le code doit déclencher un problème si quelqu'un tente d'ajouter le locuteur à une conférence. Dans une situation différente, vous savez peut-être déjà que le minimum payé pour un orateur sera de 3 000 et que seuls les orateurs ayant négocié un tarif différent verront leurs données saisies dans le champ honoraria. Dans ce cas, il convient de définir une valeur par défaut de 3000. Dans d'autres cas, différents clients peuvent avoir différents minimums. La valeur par défaut doit donc être gérée différemment (généralement via une table de recherche qui renseigne automatiquement la valeur honoraria minimale pour ce client dans le formulaire de saisie de données.
Je pense donc que la meilleure règle consiste à laisser la valeur null si vous ne pouvez vraiment pas savoir au moment de la saisie des données quelle doit être la valeur du champ. Utiliser une valeur par défaut uniquement, cela a toujours une signification pour cette situation particulière et utilisez une autre technique pour la saisir si elle peut être différente dans des circonstances différentes.
Dans un entrepôt de données, vous voudrez toujours avoir des valeurs par défaut plutôt que des valeurs NULL.
Au lieu de cela, vous aurez une valeur telle que "inconnu", "pas prêt", "manquant"
Cela permet aux INNER JOIN d'être exécutées efficacement sur les tables Fact et Dimension, car "tout a toujours une valeur"
Comme un intervenant l’a déjà dit, NULL n’est pas une valeur.
Soyez très attentif à tout ce qui est proclamé par quiconque parle de "valeur NULL" comme s'il s'agissait d'une valeur.
NULL n'est pas égal à lui-même. x = y renvoie false si x et y sont NULL. x = y est vrai si x et y sont la valeur par défaut.
Cette différence apparemment très simple a des conséquences presque infinies. Et la plupart de ces conséquences sont des pièges qui vous piquent vraiment.
Deux très bons articles sur les Nulls, axés sur l'accès, par Allen Browne:
Aspects liés au travail avec Null en code VBA:
Les articles sont orientés sur l'accès, mais pourraient être utiles à ceux qui utilisent n'importe quelle base de données, en particulier les novices relatifs en raison du style conversationnel de l'écriture.
J'apprécie tellement toute cette discussion. Je suis en train de construire un entrepôt de données et j'utilise le modèle de Kimball de manière plutôt stricte. Cependant, il existe un utilisateur très vocal qui déteste les clés de substitution et veut des valeurs NULL un peu partout. Je lui ai dit qu'il est acceptable d'avoir des colonnes NULLable pour les attributs de dimensions et pour les dates ou les nombres utilisés dans les calculs, car les valeurs par défaut impliquent des données incorrectes. Je conviens qu'il existe des avantages à autoriser NULL dans certaines colonnes, mais cela rend le cubage bien meilleur et plus fiable s'il existe une clé de substitution pour chaque clé étrangère d'une dimension, même si la substitution est -1 ou 0 pour un enregistrement factice. . SQL aime les entiers pour les jointures et s'il existe une valeur de dimension manquante et qu'un mannequin est fourni en tant que clé de substitution, vous obtiendrez le même nombre d'enregistrements en utilisant une dimension que vous le feriez sur une autre dimension. Cependant, les calculs doivent être effectués correctement et vous devez prendre en compte les valeurs NULL dans celles-ci. La date de naissance doit être NULL pour que l'âge ne soit pas calculé, par exemple. Je crois en la bonne gouvernance des données et prendre ces décisions avec les utilisateurs les oblige à réfléchir à leurs données de manière plus que jamais.
Les valeurs NULL ne permettent JAMAIS d'économiser de l'espace de stockage dans DB2 pour OS/390 et z/OS. Chaque colonne Nullable nécessite un octet de stockage supplémentaire pour l'indicateur NULL. Ainsi, une colonne CHAR (10) nullable nécessitera 11 octets de stockage par ligne - 10 pour les données et 1 pour l'indicateur NULL. C'est le cas indépendamment du fait que la colonne soit définie sur null ou non.
DB2 pour Linux, Unix et Windows dispose d'une option de compression qui permet aux colonnes définies sur null d'économiser de l'espace. Si vous utilisez cette option, DB2 éliminera l’espace inutilisé d’une ligne dans laquelle les colonnes sont définies sur null. Cette option n'est toutefois pas disponible sur le grand système.
REF: http://www.craigsmullins.com/bp7.htm
Par conséquent, la meilleure pratique de modélisation pour DB2 Z/OS consiste à utiliser "NOT NULL WITH DEFAULT" comme norme pour toutes les colonnes. C'est la même chose dans certains grands magasins que j'ai connus. Facilite la vie des programmeurs sans avoir à manipuler l'indicateur nul et économise réellement sur le stockage en éliminant la nécessité d'utiliser l'octet supplémentaire pour l'indicateur nul.