J'ai une application (les données sont stockées dans PostgreSQL), où la majorité des champs dans les tables ne sont pas toujours nuls, mais le schéma de ces tables ne les applique pas. Par exemple, regardez cette fausse table:

CREATE TABLE "tbl" (
    "id" serial,
    "name" varchar(40),
    "num" int,
    "time" timestamp
    PRIMARY KEY ("id"),
    UNIQUE ("id")
);

En outre name, num, timene sont pas explicitement déclaré que NOT NULL, en réalité , ils sont, parce que l'application se produit du côté de l' application.

Mon sentiment est qu'il devrait être changé, mais le contrepoint est que le niveau d'application s'assure que les valeurs nulles ne peuvent pas apparaître ici et que personne d'autre ne modifie manuellement la table.

Ma question est : quels sont les avantages (performances, stockage, cohérence, autre chose) et inconvénients (en supposant que j'ai déjà vérifié qu'il n'y a pas de null présents pour le moment, et de la logique métier il ne devrait pas y avoir de null) en définissant un NOT NULLcontrainte explicite ?

Nous avons un bon processus de révision du code et une documentation raisonnablement bonne, donc la possibilité qu'une nouvelle personne commette quelque chose qui brise cette contrainte n'est pas vraiment suffisante pour justifier le changement.

Ce n'est pas ma décision, c'est donc exactement pourquoi je cherche d'autres justifications. À mon avis, si quelque chose ne peut pas être nul et qu'une base de données vous permet de spécifier que quelque chose n'est pas nul, alors faites-le. Surtout si le changement est super simple.

Que se passe-t-il lorsqu'un nouveau programmeur arrive et doit écrire une application sur cette base de données? Ils ne savent pas que le champ x doit être NOT NULL.

Un autre programme pourrait supposer que tous les champs x sont NOT NULLdestinés à effectuer des comptages, mais certains le sont maintenant à NULLcause du nouveau programme, ce qui entraîne des erreurs incohérentes et difficiles à retracer.

À mon humble avis, il est toujours préférable d'appliquer les règles d'intégrité des données aussi près que possible des données, c'est-à-dire dans la base de données. De cette façon, les nouvelles applications et / ou programmeurs ne peuvent pas gâcher vos données.

Les programmeurs, les applications, les langages et les frameworks vont et viennent. Les données et les bases de données ont tendance à persister. La base de données est votre dernière ligne de défense contre les données incohérentes et potentiellement erronées.

Faire un maximum l' utilisation des mécanismes d'application de la contrainte d'intégrité de votre base de données, même au détriment de la performance. Un système lent qui produit des résultats corrects est infiniment supérieur à un système rapide qui se trompe!

Comme déjà mentionné par d'autres dans les commentaires, l'ajout NOT NULLà votre spécification de table peut améliorer de manière significative les performances de vos requêtes (en plus des très bonnes raisons méthodologiques énoncées dans une autre réponse).

La raison en est que l'optimiseur de requêtes, sachant qu'une colonne ne peut pas avoir de NULLvaleur, peut exclure des tests spéciaux pour ces valeurs, comme dans le cas NOT INvs. NOT EXISTSVous pouvez voir par exemple ce blog , où il est montré que ne pas déclarer un champ NOT NULL(lorsque la table contient toujours des valeurs non nulles) avec une certaine requête augmente le temps d'exécution de 500%. Le résultat est affiché pour SQL Server, mais un comportement similaire pourrait être présent dans d'autres SGBD relationnels, comme le vôtre (sans parler du fait que votre base de données pourrait être portée sur d'autres systèmes). Une règle générale que vous pouvez supposer est que lorsque plus d'informations sont disponibles pour l'optimiseur de requête, des plans d'accès plus efficaces peuvent être produits.

Implications spatiales

Les implications spatiales sont discutées dans cet article de @Erwin Brandstetter

En bref, vous économiserez un totalColumns - 8bit arrondi à l'octet le plus proche (ou MAXALIGN), si votre base de données a

1. Plus de 8 colonnes
2. TOUTES les colonnes du tableau sontNOT NULL

Répercussions sur les performances

Cependant, dans ce post sur SE par @Erwin Brandstetter , il dit

1. "La définition de NOT NULL n'a aucun effet en soi sur les performances. Quelques cycles pour la vérification - non pertinents."
2. "... en utilisant réellement des valeurs NULL au lieu de valeurs fictives. Selon les types de données, vous pouvez économiser beaucoup d'espace disque et de RAM, accélérant ainsi .. tout."

@Renzo a une réponse qui parle des implications en termes de performances - je suppose que rien de tout cela n'est applicable à PostgreSQL . Je ne trouve rien qui justifie tout cela comme étant pertinent pour PostgreSQL. Quels que soient les cycles enregistrés, ils ne peuvent pas être quantifiés, même dans la requête la plus rudimentaire.

CREATE TABLE foo (
  a int,
  b int NOT NULL,
  x float,
  y float NOT NULL
);

INSERT INTO foo ( a, b, x, y )
SELECT x, x, x, x
FROM generate_series(1,1E7) AS X(x);

EXPLAIN ANALYZE SELECT 1/a FROM foo;
EXPLAIN ANALYZE SELECT 1/b FROM foo;
EXPLAIN ANALYZE SELECT 1/x FROM foo;
EXPLAIN ANALYZE SELECT 1/y FROM foo;

De plus, j'ai effectué des tests pour voir si les index NULL étaient toujours plus rapides, et je n'ai pas pu le prouver. Vous pouvez trouver ce fil de discussion très utile de Scott Marlowe sur les listes de diffusion qui parle du planificateur de requêtes dans 9.1 étant capable d'utiliser un index partiel sur des clauses WHERE différentes. J'ai testé cela en exécutant ce qui suit

CREATE TABLE foo ( a int );
CREATE TABLE bar ( a int NOT NULL );
INSERT INTO foo
  SELECT null FROM generate_series(1,1e5) AS x
  UNION ALL
  SELECT 10
  UNION ALL
  SELECT null FROM generate_series(1,1e5) AS x
;
INSERT INTO bar
  SELECT 0 FROM generate_series(1,1e5) AS x
  UNION ALL
  SELECT 10
  UNION ALL
  SELECT 0 FROM generate_series(1,1e5) AS x
;

Maintenant, j'ai créé les index,

CREATE INDEX foobar ON foo(a) WHERE a IS NOT NULL;
CREATE INDEX barbar ON bar(a) WHERE a <> 0;

Dans les deux cas, le planificateur a pu utiliser l'index lors de la sélection pour = 10et utilisé un balayage seq lors de la recherche de NULL ou de 0 respectivement. Les deux indices partiels avaient la même taille. Et, les index complets (non représentés) avaient la même taille. En suivant la même méthodologie, j'ai chargé le tableau avec une séquence de 1..1e5, et une valeur null / 0, et une autre séquence de 1..1e5. Les deux méthodes ont pu trouver le null / 0 avec un index couvrant toute la table.

TLDR; Résumé

Je ne peux rien prouver d'une manière ou d'une autre sur la plupart des problèmes de performance qui, selon moi, valaient la peine d'être testés pour inclure les insuffisances du planificateur. L'avantage d'utiliser null pour enregistrer ram est réel. L'espace disque économisé en n'utilisant pas null est négligeable, et c'est une surestimation sur les tables avec une NULLABLEcolonne, ou moins de 8 colonnes. Dans ces cas, aucun espace disque n'est enregistré.