Champ de modèle Unique dans Django et sensibilité à la casse (postgres)

Vous pouvez également modifier le Gestionnaire de jeu de requêtes par défaut pour effectuer des recherches insensibles à la casse sur le champ. En essayant de résoudre un problème similaire, je suis tombé sur:

Http://djangosnippets.org/snippets/305/

Code collé ici pour plus de commodité:

from django.db.models import Manager
from django.db.models.query import QuerySet

class CaseInsensitiveQuerySet(QuerySet):
    def _filter_or_exclude(self, mapper, *args, **kwargs):
        # 'name' is a field in your Model whose lookups you want case-insensitive by default
        if 'name' in kwargs:
            kwargs['name__iexact'] = kwargs['name']
            del kwargs['name']
        return super(CaseInsensitiveQuerySet, self)._filter_or_exclude(mapper, *args, **kwargs)

# custom manager that overrides the initial query set
class TagManager(Manager):
    def get_query_set(self):
        return CaseInsensitiveQuerySet(self.model)

# and the model itself
class Tag(models.Model):
    name = models.CharField(maxlength=50, unique=True, db_index=True)

    objects = TagManager()

    def __str__(self):
        return self.name

Du côté Postgres des choses, un index unique fonctionnel vous permettra d'appliquer des valeurs uniques sans casse. citext est également noté, mais cela fonctionnera avec les anciennes versions de PostgreSQL et est une technique utile en général.

Exemple:

# create table foo(bar text);
CREATE TABLE
# create unique index foo_bar on foo(lower(bar));
CREATE INDEX
# insert into foo values ('Texas');
INSERT 0 1
# insert into foo values ('texas');
ERROR:  duplicate key value violates unique constraint "foo_bar"

Étapes explicites pour la réponse de Mayuresh:

1. Dans postgres faire: créer L'EXTENSION citext;

2. Dans votre models.py ajouter:

   from django.db.models import fields
   
   class CaseInsensitiveTextField(fields.TextField):
       def db_type(self, connection):
           return "citext"
   

   Référence: https://github.com/zacharyvoase/django-postgres/blob/master/django_postgres/citext.py

3. Dans votre modèle, utilisez: name = CaseInsensitiveTextField (unique=True)

Outre l'option déjà mentionnée pour remplacer save, vous pouvez simplement stocker tout le texte en minuscules dans la base de données et les capitaliser sur l'affichage.

class State(models.Model):
    name = models.CharField(max_length=50, unique=True)

    def save(self, force_insert=False, force_update=False):
        self.name = self.name.lower()
        super(State, self).save(force_insert, force_update)

Une solution très simple:

class State(models.Model):
    name = models.CharField(max_length=50, unique=True)

    def clean(self):
        self.name = self.name.capitalize()

Vous pouvez le faire en écrasant la méthode de sauvegarde du modèle-voir les documents . Vous feriez essentiellement quelque chose comme:

class State(models.Model):
    name = models.CharField(max_length=50, unique=True)

    def save(self, force_insert=False, force_update=False):
        if State.objects.get(name__iexact = self.name):
            return
        else:
            super(State, self).save(force_insert, force_update)

Aussi, je peux me tromper à ce sujet, mais la prochaine branche SoC model-validation nous permettra de le faire plus facilement.

Vous pouvez utiliser lookup= 'iexact' dans UniqueValidator sur serializer, comme ceci:

class StateSerializer(serializers.ModelSerializer): 
    name = serializers.CharField(validators=[
    UniqueValidator(
        queryset=models.State.objects.all(),lookup='iexact'
    )]

Version Django: 1.11.6

Solution de suhail a fonctionné pour moi sans avoir besoin d'activer citext, solution assez facile seulement une fonction propre et au lieu de capitaliser j'ai utilisé upper(). La solution de Mayuresh fonctionne également mais a changé le champ de CharField à TextField.

class State(models.Model):

    name = models.CharField(max_length=50, unique=True)

    def clean(self):
        self.name = self.name.upper()