[Django]-Case insensitive unique model fields in Django?

As of Django 1.11, you can use CITextField, a Postgres-specific Field for case-insensitive text backed by the citext type.

from django.db import models
from django.contrib.postgres.fields import CITextField

class Something(models.Model):
    foo = CITextField()

Django also provides CIEmailField and CICharField, which are case-insensitive versions of EmailField and CharField.

As of December 2021, with the help of Django 4.0 UniqueConstraint expressions you can add a Meta class to your model like this:

class Meta:
    constraints = [
        models.UniqueConstraint(
            Lower('<field name>'),
            name='<constraint name>'
        ),
    ]

I’m by no mean a Django professional developer and I don’t know technical considerations like performance issues about this solution. Hope others comment on that.

With overriding the model manager, you have two options. First is to just create a new lookup method:

class MyModelManager(models.Manager):
   def get_by_username(self, username):
       return self.get(username__iexact=username)

class MyModel(models.Model):
   ...
   objects = MyModelManager()

Then, you use get_by_username('blah') instead of get(username='blah'), and you don’t have to worry about forgetting iexact. Of course that then requires that you remember to use get_by_username.

The second option is much hackier and convoluted. I’m hesitant to even suggest it, but for completeness sake, I will: override filter and get such that if you forget iexact when querying by username, it will add it for you.

class MyModelManager(models.Manager):
    def filter(self, **kwargs):
        if 'username' in kwargs:
            kwargs['username__iexact'] = kwargs['username']
            del kwargs['username']
        return super(MyModelManager, self).filter(**kwargs)

    def get(self, **kwargs):
        if 'username' in kwargs:
            kwargs['username__iexact'] = kwargs['username']
            del kwargs['username']
        return super(MyModelManager, self).get(**kwargs)

class MyModel(models.Model):
   ...
   objects = MyModelManager()

Since a username is always lowercase, it’s recommended to use a custom lowercase model field in Django. For the ease of access and code-tidiness, create a new file fields.py in your app folder.

from django.db import models
from django.utils.six import with_metaclass

# Custom lowecase CharField

class LowerCharField(with_metaclass(models.SubfieldBase, models.CharField)):
    def __init__(self, *args, **kwargs):
        self.is_lowercase = kwargs.pop('lowercase', False)
        super(LowerCharField, self).__init__(*args, **kwargs)

    def get_prep_value(self, value):
        value = super(LowerCharField, self).get_prep_value(value)
        if self.is_lowercase:
            return value.lower()
        return value

Usage in models.py

from django.db import models
from your_app_name.fields import LowerCharField

class TheUser(models.Model):
    username = LowerCharField(max_length=128, lowercase=True, null=False, unique=True)

End Note : You can use this method to store lowercase values in the database, and not worry about __iexact.

You can use citext postgres type instead and not bother anymore with any sort of iexact. Just make a note in model that underlying field is case insensitive.
Much easier solution.

You can use lookup=’iexact’ in UniqueValidator on serializer, like this:
Unique model field in Django and case sensitivity (postgres)

I liked Chris Pratt’s Answer but it didn’t worked for me, because the models.Manager-class doesn’t have the get(...) or filter(...) Methods.
I had to take an extra step via a custom QuerySet:

from django.contrib.auth.base_user import BaseUserManager
from django.db.models import QuerySet

class CustomUserManager(BaseUserManager):

    # Use the custom QuerySet where get and filter will change 'email'
    def get_queryset(self):
        return UserQuerySet(self.model, using=self._db)

    def create_user(self, email, password, **extra_fields):
        ...

    def create_superuser(self, email, password, **extra_fields):
        ...

class UserQuerySet(QuerySet):

    def filter(self, *args, **kwargs):
        if 'email' in kwargs:
            # Probably also have to replace...
            #   email_contains -> email_icontains,
            #   email_exact -> email_iexact,
            #   etc.
            kwargs['email__iexact'] = kwargs['email']
            del kwargs['email']
        return super().filter(*args, **kwargs)

    def get(self, *args, **kwargs):
        if 'email' in kwargs:
            kwargs['email__iexact'] = kwargs['email']
            del kwargs['email']
        return super().get(*args, **kwargs)

This worked for me in a very simple case but is working pretty good so far.

You can also override get_prep_value() and reuse it through inheritance.

class LowerCaseField:
    def get_prep_value(self, value):
        value = super().get_prep_value(value)
        if value:
            value = value.strip().lower()
        return value


class LowerSlugField(LowerCaseField, models.SlugField):
    pass


class LowerEmailField(LowerCaseField, models.EmailField):
    pass


class MyModel(models.Model):
    email = LowerEmailField(max_length=255, unique=True)

This way, if you ever want to reuse this field in another model, you can use the same consistent strategy.

From Django Docs:

get_prep_value(value)

value is the current value of the model’s
attribute, and the method should return data in a format that has been
prepared for use as a parameter in a query.

See Converting Python objects to query values for usage.

one of the best options for do this is that create a form and past it exept of the admin form .
like this :

from . Import YourModel
from django import forms
from django.contrib import admin
class HandMadeFormForAdminPage(forms.ModelForm):
    class Meta:
        model = YourModel
        fields = "__all__"
    def clean(self):
        cleaned_data = super().clean()

        field_value = self.cleaned_data.get("YourFieldName")
        value_pair  = YourModel.objects.filter(YourModelFieldName__iexact=field_value).first()
        if value_pair:
            self.add_error("YourFieldName", f"the {value_pair} alredy exist")
class YourModelAdmin(admin.ModelAdmin):
       form =  HandMadeFormForAdminPage

by using def db_type you could also do something like:

from django.db import models
from django.utils.translation import gettext_lazy as _


class CaseInsensitiveCharField(models.CharField):
    description = _("Case insensitive character")

    def db_type(self, connection):
        return "citext"