Setting default value for Foreign Key attribute in Django

Question

What is the best way to set a default value for a foreign key field in a model? Suppose I have two models, Student and Exam with student having exam_taken as foreign key. How would I ideally set a default value for it? Here's a log of my effort

class Student(models.Model):
   ....
   .....
   exam_taken = models.ForeignKey("Exam", default=1)

Works, but have a hunch there's a better way.

def get_exam():
    return Exam.objects.get(id=1)
    
class Student(models.Model):
    ....
    .....
    exam_taken = models.ForeignKey("Exam", default=get_exam)

But this fails with tables does not exist error while syncing.

Any help would be appreciated.

how about: http://stackoverflow.com/questions/937954/how-do-you-specify-a-default-for-a-django-foreignkey-model-or-adminmodel-field — Nitzan Tomer, Feb 16 '12 at 13:55
@NitzanTomer It for a AdminModelField. Had seen it previously. — Primal Pappachan, Feb 16 '12 at 14:04
@TomIngram: `default=get_exam()` will call `get_exam` immediately and store the value permanently, whereas `default=get_exam` stores the method which would later be called each time the `default` attribute is used, to get the value at that moment. It's often used with datetime, i.e. `default=datetime.now`, *not* `default=datetime.now()`. — Chris Pratt, Feb 16 '12 at 15:33
@TomIngram: I'm not debating the merits of one approach over another. My point was only that it is valid, and the author seems to want it that way. — Chris Pratt, Feb 16 '12 at 16:32
@ChrisPratt "This can be a value or a callable object. If callable it will be called every time a new object is created." so this means `default=get_exam()` and `default=get_exam` effectively is the same, unless you can re-call default? — T I, Feb 16 '12 at 16:52
@TomIngram: The difference is that when you add the parenthesis, it's no longer a "callable"; it's a static value, no different that just putting an integer there. — Chris Pratt, Feb 16 '12 at 20:23
@ChrisPratt hello I understand the difference etc, what I guess I'm struggling with is working out why. Giving it a bit of thought I'm thinking that as external states change perhaps the required default value will also and you would need to re-evaluate this value using the callback you passed, maybe I'm also over emphasising or misinterpreting `default` as to me it reads as something that should be relatively static, thanks it's been interesting and thought provoking for me at least :) — T I, Feb 16 '12 at 21:03

djvg · Answer 1 · 2022-10-20T06:49:48.163

30

As already implied in @gareth's answer, hard-coding a default id value might not always be the best idea:

If the id value does not exist in the database, you're in trouble. Even if that specific id value does exist, the corresponding object may change. In any case, when using a hard-coded id value, you'd have to resort to things like data-migrations or manual editing of existing database content.

To prevent that, you could use get_or_create() in combination with a unique field (other than id).

Here's one way to do it:

from django.db import models

 
class Exam(models.Model):
    title = models.CharField(max_length=255, unique=True)
    description = models.CharField(max_length=255)
    
    @classmethod
    def get_default_pk(cls):
        exam, created = cls.objects.get_or_create(
            title='default exam', 
            defaults=dict(description='this is not an exam'),
        )
        return exam.pk
    
    
class Student(models.Model):
    exam_taken = models.ForeignKey(
        to=Exam, on_delete=models.CASCADE, default=Exam.get_default_pk
    )

Here an Exam.title field is used to get a unique object, and an Exam.description field illustrates how we can use the defaults argument (for get_or_create) to fully specify the default Exam object.

Note that we return a pk, as suggested by the docs:

For fields like ForeignKey that map to model instances, defaults should be the value of the field they reference (pk unless to_field is set) instead of model instances.

Also note that default callables are evaluated in Model.__init__() (source). So, if your default value depends on another field of the same model, or on the request context, or on the state of the client-side form, you should probably look elsewhere.

edited Oct 20 '22 at 06:49

answered Jul 02 '20 at 13:48

djvg

11,722
5
72
103

It doesn't work if U have not any migrations yet for me. I use field role for User, where I use `get_default_user_role` callback as default parameter like in your example. So if I have no migrations I got `no such table: users_role` on `python manage.py makemigration`. But if I comment `role field` in *User* model and `run makemigrations` - it is no problems. After what I uncomment `role field` and `run migrations` again with no problems. Maybe U can halp me with that? – parfeniukink Oct 15 '20 at 20:59
@parfeniukink: I would be happy to help, but it is a bit difficult to tell what is going wrong without seeing your actual code. Perhaps you could create a new Question with some more details? – djvg Oct 16 '20 at 07:10
Oh, Thanks a lot, but I've finished this task ))) – parfeniukink Nov 04 '20 at 19:54
I like the approach but get_or_create returns a tuple object and tuple have no pk ! exam[0] would have pk ! – Elcast Oct 19 '22 at 20:31
2

@Elcast If you look closely, the [tuple is unpacked](https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences) in the example: `exam, created = cls.objects.get_or_create(...)`, so the first item is assigned to `exam`, the second item is assigned to `created`. Exactly like the [example in the Django docs](https://docs.djangoproject.com/en/4.1/ref/models/querysets/#get-or-create). – djvg Oct 19 '22 at 21:29
You're correct, I have not followed (copy paste) your code 100% so I got different results, adding created make sense now. Thanks for share and the explanation.. – Elcast Oct 20 '22 at 03:11

score 25 · Answer 2 · answered Aug 14 '18 at 02:18

I would modify @vault's answer above slightly (this may be a new feature). It is definitely desirable to refer to the field by a natural name. However instead of overriding the Manager I would simply use the to_field param of ForeignKey:

class Country(models.Model):
    sigla   = models.CharField(max_length=5, unique=True)

    def __unicode__(self):
        return u'%s' % self.sigla

class City(models.Model):
    nome   = models.CharField(max_length=64, unique=True)
    nation = models.ForeignKey(Country, to_field='sigla', default='IT')

vault · Answer 3 · 2018-07-09T10:23:30.533

14

I use natural keys to adopt a more natural approach:

<app>/models.py

from django.db import models

class CountryManager(models.Manager):
    """Enable fixtures using self.sigla instead of `id`"""

    def get_by_natural_key(self, sigla):
        return self.get(sigla=sigla)

class Country(models.Model):
    objects = CountryManager()
    sigla   = models.CharField(max_length=5, unique=True)

    def __unicode__(self):
        return u'%s' % self.sigla

class City(models.Model):
    nome   = models.CharField(max_length=64, unique=True)
    nation = models.ForeignKey(Country, default='IT')

edited Jul 09 '18 at 10:23

answered Jan 21 '14 at 16:34

vault

3,930
1
35
46

4

I tried this in Django 1.6 but I get the error, "Invalid literal for int() with base 10: 'IT'. (My string is different, but you get the idea.) – Seth May 07 '14 at 18:30
3

This worked fine, though, and seems more Pythonic: `default=lambda: Country.objects.filter(sigla='IT').first()` – Seth May 07 '14 at 18:44
Strange, I remember to have tested this with django 1.6. Googling I found it's a tuple problem, try: `def get_by_natural_key(self, sigla): return (self.get(sigla=sigla),)` or also with `default=('IT',)`. I'm just guessing ;) – vault May 08 '14 at 10:37
"Natural" is a problematic concept here. What you seem to be saying is that you're forcing the user to choose a five-character ID for each item, but that is not inherently more natural than a serial number. – grvsmth Nov 26 '20 at 16:03

score 10 · Answer 4 · answered Apr 28 '21 at 10:43

The issue with most of these approaches are that they use HARD CODED values or lambda methods inside the Model which are not supported anymore since Django Version 1.7.

In my opinion, the best approach here is to use a sentinel method which can also be used for the on_delete argument.

So, in your case, I would do

# Create or retrieve a placeholder
def get_sentinel_exam():
    return Exam.objects.get_or_create(name="deleted",grade="N/A")[0]

# Create an additional method to return only the id - default expects an id and not a Model object
def get_sentinel_exam_id():
    return get_sentinel_exam().id

class Exam(models.Model):
    ....
    # Making some madeup values
    name=models.CharField(max_length=200) # "English", "Chemistry",...
    year=models.CharField(max_length=200) # "2012", "2022",...

class Student(models.Model):
    ....
    .....
    exam_taken = models.ForeignKey("Exam",    
                       on_delete=models.SET(get_sentinel_exam),
                       default=get_sentinel_exam_id
                 )

Now, when you just added the exam_taken field uses a guaranteed existing value while also, when deleting the exam, the Student themself are not deleted and have a foreign key to a deleted value.

This worked perfectly — I had a website admin where there were overall site settings, and one of them was the default language. I don't know in advance which languages will be available, and this enabled me to provide a default of "undefined". — Andy Swift, Mar 02 '22 at 16:00
What about performance? It doesn't execute a database hit for every call? — realnot, Nov 03 '22 at 14:12
@realnot It's been some time that I used it, so this may be opinionated. Calling the `get_sentinel_exam` method executes a query whenever a referential action is invoked (`ON DELETE` in this case). So to answer your question - unless you don't delete a row, a second query is not performed — Advena, Nov 08 '22 at 10:41

score 9 · Answer 5 · answered Nov 25 '16 at 23:43

In my case, I wanted to set the default to any existing instance of the related model. Because it's possible that the Exam with id 1 has been deleted, I've done the following:

class Student(models.Model):
    exam_taken = models.ForeignKey("Exam", blank=True)

    def save(self, *args, **kwargs):
        try:
            self.exam_taken
        except:
            self.exam_taken = Exam.objects.first()
        super().save(*args, **kwargs)

If exam_taken doesn't exist, django.db.models.fields.related_descriptors.RelatedObjectDoesNotExist will be raised when a attempting to access it.

score 4 · Answer 6 · answered Jun 04 '14 at 09:57

You could use this pattern:

class Other(models.Model):
    DEFAULT_PK=1
    name=models.CharField(max_length=1024)

class FooModel(models.Model):
    other=models.ForeignKey(Other, default=Other.DEFAULT_PK)

Of course you need to be sure that there is a row in the table of Other. You should use a datamigration to be sure it exists.

Super Kai - Kazuya Ito · Answer 7 · 2023-05-11T07:41:23.473

You need to use get_or_create() in get_exam() and on_delete for models.ForeignKey() as shown below. *Don't forget to put .id just after get_or_create(id=1)[0] because default in models.ForeignKey() needs id of an Exam object otherwise there is an error and you can see my answer explaining about get_or_create():

def get_exam():        # Here                # ↓ Don't forget
    return Exam.objects.get_or_create(id=1)[0].id

class Student(models.Model):
    # ...
    exam_taken = models.ForeignKey(
        "Exam", 
        default=get_exam, 
        on_delete=models.CASCADE # Here
    )

And, you can put get_exam() in Student class as shown below:

class Student(models.Model):
    # ...
    def get_exam(): # Here
        return Exam.objects.get_or_create(id=1)[0].id

    exam_taken = models.ForeignKey(
        "Exam", 
        default=get_exam, 
        on_delete=models.CASCADE
    )

I recommend to use @classmethod for get_exam() in Student class as shown below so that other classes can also use get_exam() by class name. *@classmethod can do more things than @staticmethod according to my answer:

class Student(models.Model):
    # ...
    @classmethod # Here
    def get_exam(cls):
        return Exam.objects.get_or_create(id=1)[0].id

    exam_taken = models.ForeignKey(
        "Exam", 
        default=get_exam, 
        on_delete=models.CASCADE
    )

And instead of get_exam, you can assign get_exam() to default as shown below:

def get_exam():
    return Exam.objects.get_or_create(id=1)[0].id

class Student(models.Model):
    # ...
    exam_taken = models.ForeignKey(
        "Exam", # ↓ Here ↓
        default=get_exam(),
        on_delete=models.CASCADE
    )

class Student(models.Model):
    # ...
    def get_exam():
        return Exam.objects.get_or_create(id=1)[0].id

    exam_taken = models.ForeignKey(
        "Exam", # ↓ Here ↓
        default=get_exam(), 
        on_delete=models.CASCADE
    )

score 0 · Answer 8 · answered Apr 03 '20 at 03:32

I'm looking for the solution in Django Admin, then I found this:

class YourAdmin(admin.ModelAdmin)

    def get_changeform_initial_data(self, request):
        return {'owner': request.user}

this also allows me to use the current user.

see django docs

DeyaEldeen · Answer 9 · 2020-08-12T08:29:23.333

0

the best way I know is to use lambdas

class TblSearchCase(models.Model):
    weights = models.ForeignKey('TblSearchWeights', models.DO_NOTHING, default=lambda: TblSearchWeights.objects.get(weight_name='value_you_want'))

so you can specify the default row..

default=lambda: TblSearchWeights.objects.get(weight_name='value_you_want')

edited Aug 12 '20 at 08:29

answered Aug 12 '20 at 08:24

DeyaEldeen

10,847
10
42
75

Error: Cannot serialize function 'lambda' – Michael Sep 13 '22 at 19:20
that was Django 2, I'm not sure about 3 or 4. – DeyaEldeen Sep 13 '22 at 21:15

Setting default value for Foreign Key attribute in Django

9 Answers9

Linked