Champs uniques autorisant les valeurs nulles dans Django

Question

J'ai un modèle Foo qui a un champ bar. Le champ bar doit être unique, mais il peut contenir des nuls, ce qui signifie que je veux autoriser plus d'un enregistrement si le champ bar a la valeur suivante null mais si ce n'est pas le cas null les valeurs doivent être uniques.

Voici mon modèle :

class Foo(models.Model):
    name = models.CharField(max_length=40)
    bar = models.CharField(max_length=40, unique=True, blank=True, null=True, default=None)

Et voici le SQL correspondant pour la table :

CREATE TABLE appl_foo
(
    id serial NOT NULL,
     "name" character varying(40) NOT NULL,
    bar character varying(40),
    CONSTRAINT appl_foo_pkey PRIMARY KEY (id),
    CONSTRAINT appl_foo_bar_key UNIQUE (bar)
)   

Lorsque j'utilise l'interface d'administration pour créer plus d'un objet foo où bar est nul, je reçois une erreur : "Foo avec cette barre existe déjà".

Cependant, lorsque j'insère dans la base de données (PostgreSQL) :

insert into appl_foo ("name", bar) values ('test1', null)
insert into appl_foo ("name", bar) values ('test2', null)

Cela fonctionne très bien, cela me permet d'insérer plus d'un enregistrement avec la barre étant nulle, donc la base de données me permet de faire ce que je veux, c'est juste quelque chose qui ne va pas avec le modèle Django. Avez-vous une idée ?

EDIT

La portabilité de la solution en ce qui concerne la base de données n'est pas un problème, nous sommes satisfaits de Postgres. J'ai essayé de mettre unique à un callable, qui était ma fonction retournant Vrai/Faux pour des valeurs spécifiques de bar Il n'y a pas eu d'erreur, mais il semble que cela n'ait pas eu d'effet du tout.

Jusqu'à présent, j'ai supprimé le spécificateur unique de l'option bar et le traitement de la propriété bar l'unicité de l'application, mais je suis toujours à la recherche d'une solution plus élégante. Des recommandations ?

Answer 1

Django ne considère pas que NULL est égal à NULL dans le cadre des contrôles d'unicité depuis la correction du ticket #9039, voir :

http://code.djangoproject.com/ticket/9039

Le problème est que la valeur normalisée "vide" d'un champ de formulaire CharField est une chaîne vide, et non None. Donc, si vous laissez le champ vide, vous obtenez une chaîne vide, et non NULL, stockée dans la base de données. Les chaînes vides sont égales aux chaînes vides pour les contrôles d'unicité, selon les règles de Django et de la base de données.

Vous pouvez forcer l'interface d'administration à enregistrer NULL pour une chaîne vide en fournissant votre propre formulaire de modèle personnalisé pour Foo avec une méthode clean_bar qui transforme la chaîne vide en None :

class FooForm(forms.ModelForm):
    class Meta:
        model = Foo
    def clean_bar(self):
        return self.cleaned_data['bar'] or None

class FooAdmin(admin.ModelAdmin):
    form = FooForm

Answer 2

** modifier 11/30/2015 : Dans python 3, le module-global __metaclass__ La variable est n'est plus supporté . En outre, à partir de Django 1.10 le site SubfieldBase La classe était déprécié :

de la docs :

django.db.models.fields.subclassing.SubfieldBase a été déprécié et sera supprimé dans Django 1.10. Historiquement, il était utilisé pour gérer les champs pour lesquels une conversion de type était nécessaire lors du chargement depuis la base de données, mais il n'était pas utilisé dans .values() des appels ou des agrégats. Il a été remplacé par from_db_value() . Notez que la nouvelle approche n'appelle pas le to_python() méthode en mission, comme ce fut le cas pour SubfieldBase .

Par conséquent, comme le suggère le from_db_value() documentation et ceci exemple cette solution doit être modifiée en :

class CharNullField(models.CharField):

    """
    Subclass of the CharField that allows empty strings to be stored as NULL.
    """

    description = "CharField that stores NULL but returns ''."

    def from_db_value(self, value, expression, connection, contex):
        """
        Gets value right out of the db and changes it if its ``None``.
        """
        if value is None:
            return ''
        else:
            return value

    def to_python(self, value):
        """
        Gets value right out of the db or an instance, and changes it if its ``None``.
        """
        if isinstance(value, models.CharField):
            # If an instance, just return the instance.
            return value
        if value is None:
            # If db has NULL, convert it to ''.
            return ''

        # Otherwise, just return the value.
        return value

    def get_prep_value(self, value):
        """
        Catches value right before sending to db.
        """
        if value == '':
            # If Django tries to save an empty string, send the db None (NULL).
            return None
        else:
            # Otherwise, just pass the value.
            return value

---

Je pense qu'un meilleur moyen que de surcharger le cleaned_data dans l'administration serait de sous-classer le champ de caractères - de cette façon, quel que soit le formulaire accédant au champ, il va "juste fonctionner". Vous pouvez attraper le '' juste avant qu'il soit envoyé à la base de données, et attraper le NULL juste après qu'il soit sorti de la base de données, et le reste de Django n'en saura rien. Un exemple rapide et sale :

from django.db import models

class CharNullField(models.CharField):  # subclass the CharField
    description = "CharField that stores NULL but returns ''"
    __metaclass__ = models.SubfieldBase  # this ensures to_python will be called

    def to_python(self, value):
        # this is the value right out of the db, or an instance
        # if an instance, just return the instance
        if isinstance(value, models.CharField):
            return value 
        if value is None:  # if the db has a NULL (None in Python)
            return ''      # convert it into an empty string
        else:
            return value   # otherwise, just return the value

    def get_prep_value(self, value):  # catches value right before sending to db
        if value == '':   
            # if Django tries to save an empty string, send the db None (NULL)
            return None
        else:
            # otherwise, just pass the value
            return value  

Pour mon projet, je l'ai placé dans un fichier extras.py qui se trouve dans la racine de mon site, alors je peux juste from mysite.extras import CharNullField dans l'application models.py fichier. Le champ se comporte comme un CharField - n'oubliez pas de définir le paramètre blank=True, null=True lors de la déclaration du champ, sinon Django lancera une erreur de validation (champ requis) ou créera une colonne de base de données qui n'accepte pas NULL.

Answer 3

La solution rapide est de faire :

def save(self, *args, **kwargs):

    if not self.bar:
        self.bar = None

    super(Foo, self).save(*args, **kwargs)

Answer 4

Une autre solution possible

class Foo(models.Model):
    value = models.CharField(max_length=255, unique=True)

class Bar(models.Model):
    foo = models.OneToOneField(Foo, null=True)

Answer 5

Pour le meilleur ou pour le pire, Django considère NULL pour être équivalent à NULL pour les besoins des contrôles d'unicité. Il n'y a pas vraiment de moyen de contourner ce problème, à moins d'écrire votre propre implémentation de la vérification d'unicité qui considère NULL pour être unique, quel que soit le nombre de fois où il apparaît dans une table.

(et gardez à l'esprit que certaines solutions de DB adoptent le même point de vue sur les NULL Ainsi, un code reposant sur les idées d'un DB concernant NULL peut ne pas être transférable à d'autres)