They are equal:

    &gt;&gt;&gt; str(Person.objects.filter(age__isnull=True).query) == str(Person.objects.filter(age=None).query)
    True
    &gt;&gt;&gt; print(Person.objects.filter(age=None).query)
    SELECT &quot;person_person&quot;.&quot;id&quot;, &quot;person_person&quot;.&quot;name&quot;, &quot;person_person&quot;.&quot;yes&quot;, &quot;person_person&quot;.&quot;age&quot; FROM &quot;person_person&quot; WHERE &quot;person_person&quot;.&quot;age&quot; IS NULL
    &gt;&gt;&gt; print(Person.objects.filter(age__isnull=True).query)
    SELECT &quot;person_person&quot;.&quot;id&quot;, &quot;person_person&quot;.&quot;name&quot;, &quot;person_person&quot;.&quot;yes&quot;, &quot;person_person&quot;.&quot;age&quot; FROM &quot;person_person&quot; WHERE &quot;person_person&quot;.&quot;age&quot; IS NULL

Exclusion: the Postgres JSON field (see the answer of @cameron-lee)

It depends on the type of field. As mentioned in other answers, they are usually equivalent but in general, this isn&#39;t guaranteed.

For example, the Postgres JSON field uses `=None` to specify that the json has the value `null` while `__isnull=True` means there is no json:

https://docs.djangoproject.com/en/3.0/ref/contrib/postgres/fields/#jsonfield

[![null json vs no json][1]][1]


  [1]: https://i.stack.imgur.com/FXMXM.png

Just to keep in mind that you cannot reverse the condition with your first solution:


    # YOU CANNOT DO THIS
    queryset = Model.objects.filter(field!=None)

However you can do this:

    queryset = Model.objects.filter(field__isnull=False)

I&#39;m using ECMAScript6 modules. What is the correct way to export/import multiple methods from a module from the options below?

Single class of static methods:

    //------ myClass.js ------

    export default class myClass {
      
      static myMethod1() {
        console.log(&#39;foo&#39;); 
      }
      
      static myMethod2(args...) {
        console.log(&#39;bar&#39;); 
      }  
      
    }

    //------ app.js ------

    import myClass from &#39;myClass&#39;;
    myClass.myMethod1();    //foo
    


Multiple exported methods:

    //------ myMethods.js ------

    export function myMethod1() {
    	console.log(&#39;foo&#39;);
    }

    export function myMethod2() {
    	console.log(&#39;bar&#39;);
    }

    //------ app.js ------
    import {myMethod1, myMethod2} from &#39;myMethods&#39;;
    myMethod1()    //foo;


    //OR
    import * as myMethods from &#39;myMethods&#39;;
    myMethods.myMethod1()    //foo;


1) Exporting:
A class of just static methods feels like a bit of a &#39;code smell&#39; but similarly exporting everything individually does feel a bit verbose. Is it simply developer preference or are there performance implications here?

2) Importing:
&#39;* as&#39; syntax is my preferred method as it allows you to use the dot notation (referencing both the module AND the method) aiding code readability. Does this have performance implications though when I may only be using 1 of the methods?

ES6 modules: Export single class of static methods OR multiple individual methods

I have simple code below

	FragmentManager fragmentManager = getFragmentManager();
	FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
	fragmentTransaction.replace(R.id.fragment_container, mFeedFragment);
	fragmentTransaction.addToBackStack(null);
	fragmentTransaction.commit();

What do these lines of code do?

What does FragmentManager and FragmentTransaction exactly do?

this is a simple question. I&#39;d like to know if it is the same to write:

    queryset = Model.objects.filter(field=None)

than:

    queryset = Model.objects.filter(field__isnull=True)

I&#39;m using django 1.8

Django Query __isnull=True or = None

this is a simple question. I'd like to know if it is the same to write:
<pre><code class="hljs language-ini">queryset = Model.objects.filter(field=None)
</code></pre>
than:
<pre><code class="hljs language-ini">queryset = Model.objects.filter(field__isnull=True)
</code></pre>
I'm using django 1.8

I started a django 1.8 project, which uses the migrations system.  
Somehow along the way things got messy, so I erased the migrations folders and table from the DB, and now I&#39;m trying to reconstruct them, with no success.  

I have three apps (3 `models.py` files), and the models reflect the tables EXACTLY!  

The best approach that I&#39;ve found so far was:

1. Erase all `migrations` folders. Done!
2. Delete everything from the `django_migrations` table. Done!
3. Run `python manage.py makemigrations --empty &lt;app&gt;` for every app. Done!
4. Run `python manage.py migrate --fake`. Done! (although it works only if I run it after every `makemigrations` command.

Now I add a new field, run the `makemigrations` command, and I receive the following error:  
`django.db.utils.OperationalError: (1054, &quot;Unknown column &#39;accounts_plan.max_item_size&#39; in &#39;field list&#39;&quot;)`  

I&#39;ve been burning HOURS on this thing.  How the h**l can I initialize the migrations so I can continue working without migration interruptions every time?  

Why is it so complicated? Why isn&#39;t there a simple one-liner: `initiate_migrations_from_schema`?

EDIT:  
Now things get even nastier. I truncated the `django_migrations` table and deleted all the `migrations` folder.  
Now I try to run `python manage.py migrate --fake-initial` (something I found in the DEV docs), just so it sets up all of Django&#39;s &#39;internal&#39; apps (auth, session, etc) and I&#39;m getting:  
`(1054, &quot;Unknown column &#39;name&#39; in &#39;django_content_type&#39;&quot;)`.  
Now, this &quot;column&quot; is not a real column. It&#39;s a `@property` defined in Django&#39;s `contenttypes` app. WHAT IS GOING ON HERE? Why is it identifying the `name` property as a real column?

Django 1.8: Create initial migrations for existing schema

With Django REST Framework, a standard ModelSerializer will allow ForeignKey model relationships to be assigned or changed by POSTing an ID as an Integer.

What&#39;s the *simplest* way to get this behavior out of a nested serializer?

Note, I am only talking about assigning existing database objects, *not* nested creation.

I have hacked away around this in the past with additional &#39;id&#39; fields in the serializer and with custom `create` and `update` methods, but this is such a seemingly simple and frequent issue for me that I&#39;m curious to know the best way.


&lt;!-- language: python --&gt;

    class Child(models.Model):
        name = CharField(max_length=20)
    
    class Parent(models.Model):
        name = CharField(max_length=20)
        phone_number = models.ForeignKey(PhoneNumber)
        child = models.ForeignKey(Child)
    
    class ChildSerializer(ModelSerializer):
        class Meta:
            model = Child
    
    class ParentSerializer(ModelSerializer):
        # phone_number relation is automatic and will accept ID integers
        children = ChildSerializer() # this one will not
        
        class Meta:
            model = Parent

DRF: Simple foreign key assignment with nested serializers?

According to the documentation here:
https://docs.djangoproject.com/en/1.8/topics/migrations/ it says:
    
    migrate, which is responsible for applying migrations, as well as unapplying and listing their status.

and

    makemigrations, which is responsible for creating new migrations based on the changes you have made to your models.

From what I understand, I first do

    makemigrations

to create the migration file and then do

    migrate

to actually apply the migration?

Do note though that I just began my Django project and I added my app to my &quot;installed_apps&quot; list. After that, I did

    python manage.py runserver

and it said 

    You have unapplied migrations; your app may not work properly until they are applied. Run &#39;python manage.py migrate&#39; to apply them.

It didn&#39;t mention anything about running makemigrations.


Django 1.8 - what&#39;s the difference between migrate and makemigrations?

I activated a [virtualenv][1] which has pip installed. I did

```lang-none
pip3 install Django==1.8
```

and Django successfully downloaded. Now, I want to open up the Django folder. Where is the folder located?

Normally it would be in &quot;downloads&quot;, but I&#39;m not sure where it would be if I installed it using pip in a virtualenv.

  [1]: http://pypi.python.org/pypi/virtualenv





Where does pip install its packages?

I&#39;ve tried something like this, it does not work. 

    class PostSerializer(serializers.ModelSerializer):

        class Meta:
            model = Post

        def save(self):
            user = self.context[&#39;request.user&#39;]
            title = self.validated_data[&#39;title&#39;]
            article = self.validated_data[&#39;article&#39;]

I need a way of being able to access request.user from my Serializer class.  

How to get Request.User in Django-Rest-Framework serializer?

I keep getting the following error when doing a migration (python manage.py migrate):

    django.db.utils.ProgrammingError: column &quot;name&quot; of relation &quot;django_content_type&quot; does not exist

I&#39;ve done the following to try and fix it but without success:

 1. I&#39;ve delete all the migrations files for each model
 2. deleted all the records in django_migrations
 3. run python manage.py migrate --fake-initial

Running Django 1.8.2.

 

    python manage.py showmigrations
    admin
     [ ] 0001_initial
    auth
     [ ] 0001_initial
     [ ] 0002_alter_permission_name_max_length
     [ ] 0003_alter_user_email_max_length
     [ ] 0004_alter_user_username_opts
     [ ] 0005_alter_user_last_login_null
     [ ] 0006_require_contenttypes_0002
    contenttypes
     [X] 0001_initial
     [ ] 0002_remove_content_type_name
    hashtags
     [ ] 0001_initial
     [ ] 0002_hashtagvisit_user
    posts
     [ ] 0001_initial
     [ ] 0002_auto_20150530_0715
    sessions
     [ ] 0001_initial
    users
     [ ] 0001_initial

Thanks for the help. 


Django column &quot;name&quot; of relation &quot;django_content_type&quot; does not exist

Consider simple Django models `Event` and `Participant`:

    class Event(models.Model):
        title = models.CharField(max_length=100)
    
    class Participant(models.Model):
        event = models.ForeignKey(Event, db_index=True)
        is_paid = models.BooleanField(default=False, db_index=True)
    
It&#39;s easy to annotate events query with total number of participants:

    events = Event.objects.all().annotate(participants=models.Count(&#39;participant&#39;))

**How to annotate with count of participants filtered by `is_paid=True`?**

I need to query **all events** regardless of number of participants, e.g. I don&#39;t need to filter by annotated result. If there are `0` participants, that&#39;s ok, I just need `0` in annotated value.

The [example from documentation](https://docs.djangoproject.com/en/1.8/topics/db/aggregation/#order-of-annotate-and-filter-clauses) doesn&#39;t work here, because it excludes objects from query instead of annotating them with `0`.

**Update.** Django 1.8 has new [conditional expressions feature](https://docs.djangoproject.com/en/1.8/ref/models/conditional-expressions/), so now we can do like this:

    events = Event.objects.all().annotate(paid_participants=models.Sum(
        models.Case(
            models.When(participant__is_paid=True, then=1),
            default=0,
            output_field=models.IntegerField()
        )))


**Update 2.** Django 2.0 has new [Conditional aggregation](https://docs.djangoproject.com/en/2.0/ref/models/conditional-expressions/#conditional-aggregation) feature, see [the accepted answer](https://stackoverflow.com/a/48649024/326406) below.

**Update 3.** For Django 3.x please [check this answer below](https://stackoverflow.com/a/70234015/326406).

How to filter objects for count annotation in Django?

In Django doc,

&gt;  [```select_related()```](https://docs.djangoproject.com/en/stable/ref/models/querysets/#select-related) &quot;follows&quot; foreign-key relationships, selecting additional related-object data when it executes its query.
&gt;
&gt; [```prefetch_related()```](https://docs.djangoproject.com/en/stable/ref/models/querysets/#prefetch-related) does a separate lookup for each relationship, and does the &quot;joining&quot; in Python.

What does it mean by &quot;doing the joining in python&quot;? Can someone illustrate with an example?

My understanding is that for foreign key relationship, use `select_related`; and for M2M relationship, use `prefetch_related`. Is this correct?

What&#39;s the difference between select_related and prefetch_related in Django ORM?

I am trying to get unique IDs for my Django objects.  In Django 1.8 they have the UUIDField.  I am unsure how to use this field in order to generate unique IDs for each object in my model.

Here is what I have for the UUIDField

    import uuid
    from django.db import models

    class MyUUIDModel(models.Model):
        id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)

    class Person(models.Model):
        ...
        unique_id = MyUUIDModel()

I can reproduce the id for the UUID model, but everytime I do I get the exact same id. For Example: 

    person = Person.objects.get(some_field = some_thing)
    id = person.unique_id.id

id then gives me the same id every time.  What is wrong, how do I fix this?  



How to use UUID

Django Rest Framework serializers do not call the `Model.clean` when validating model serializers. The explanation given is that this leads to &#39;cleaner separation of concerns&#39;, [from the Django Rest Framework 3.0 release notes](https://www.django-rest-framework.org/community/3.0-announcement/#differences-between-modelserializer-validation-and-modelform): 

&gt; ## Differences between ModelSerializer validation and ModelForm.
&gt; This change also means that we no longer use the `.full_clean()` method
&gt; on model instances, but instead perform all validation explicitly on
&gt; the serializer. This gives a cleaner separation, and ensures that
&gt; there&#39;s no automatic validation behavior on ModelSerializer classes
&gt; that can&#39;t also be easily replicated on regular Serializer classes.

But **what** concerns are the authors of Django Rest Framework attempting to separate? 

____

My guess is that they&#39;re saying that a model instance should not be concerned about it&#39;s own validity. If that&#39;s the case I don&#39;t understand why.

Why does Django Rest Framework discourage model level validation?

&lt;!-- language-all: python --&gt;

Let&#39;s say I have a `Product` model with products in a storefront, and a `ProductImages` table with images of the product, which can have zero or more images. Here&#39;s a simplified example:

    class Product(models.Model):
      product_name = models.CharField(max_length=255)
      # ...
    
    class ProductImage(models.Model):
      product = models.ForeignKey(Product, related_name=&#39;images&#39;)
      image_file = models.CharField(max_length=255)
      # ...
  
When displaying search results for products, I want to prioritize products which have images associated with them. I can easily get the number of images:

    from django.db.models import Count
    Product.objects.annotate(image_count=Count(&#39;images&#39;))

But that&#39;s not actually what I want. I&#39;d like to annotate it with a boolean field, `have_images`, indicating whether the product has one or more images, so that I can sort by that:

    Product.objects.annotate(have_images=(?????)).order_by(&#39;-have_images&#39;, &#39;product_name&#39;)

How can I do that? Thanks!

Django query annotation with boolean field

Using Django ORM, can one do something like `queryset.objects.annotate(Count(&#39;queryset_objects&#39;, gte=VALUE))`. Catch my drift? 

------------

Here&#39;s a quick example to use for illustrating a possible answer:

In a Django website, content creators submit articles, and regular users view (i.e. read) the said articles. Articles can either be published (i.e. available for all to read), or in draft mode. The models depicting these requirements are:

    class Article(models.Model):
        author = models.ForeignKey(User)
        published = models.BooleanField(default=False)
    
    class Readership(models.Model):
        reader = models.ForeignKey(User)
        which_article = models.ForeignKey(Article)
        what_time = models.DateTimeField(auto_now_add=True)

**My question is:** How can I get all published articles, sorted by unique readership from the last 30 mins? I.e. I want to count how many distinct (unique) views each published article got in the last half an hour, and then produce a list of articles sorted by these distinct views.

------------

I tried:

    date = datetime.now()-timedelta(minutes=30)
    articles = Article.objects.filter(published=True).extra(select = {
      &quot;views&quot; : &quot;&quot;&quot;
      SELECT COUNT(*)
      FROM myapp_readership
        JOIN myapp_article on myapp_readership.which_article_id = myapp_article.id
      WHERE myapp_readership.reader_id = myapp_user.id
      AND myapp_readership.what_time &gt; %s &quot;&quot;&quot; % date,
    }).order_by(&quot;-views&quot;)

This sprang the error: **syntax error at or near &quot;01&quot;** (where &quot;01&quot; was the datetime object inside extra). It&#39;s not much to go on.

How to annotate Count with a condition in a Django queryset

I have a model `MyModel` with a boolean field `active`

Elsewhere, I am retrieving a queryset:

    qs = MyModel.Objects.filter(....) 

how can I set `active=False` for all objects in this `qs`?

Django: change the value of a field for all objects in a queryset

In Django, what&#39;s the difference between the following two:

    Article.objects.values_list(&#39;comment_id&#39;, flat=True).distinct()

vs 

    Article.objects.values(&#39;comment_id&#39;).distinct()

My goal is to get a list of unique comment ids under each `Article`. I&#39;ve read the documentation (and in fact have used both approaches). The results overtly seem similar.


Django values_list vs values

I am trying to make a very simple `Subquery` that uses `OuterRef` (not for practical purposes, but just to get it working), but I keep running into the same error.

`posts/models.py` code


    from django.db import models

    class Tag(models.Model):
        name = models.CharField(max_length=120)
        def __str__(self):
            return self.name

    class Post(models.Model):
        title = models.CharField(max_length=120)
        tags = models.ManyToManyField(Tag)
        def __str__(self):
            return self.title

`manage.py shell` code

    &gt;&gt;&gt; from django.db.models import OuterRef, Subquery
    &gt;&gt;&gt; from posts.models import Tag, Post
    &gt;&gt;&gt; tag1 = Tag.objects.create(name=&#39;tag1&#39;)
    &gt;&gt;&gt; post1 = Post.objects.create(title=&#39;post1&#39;)
    &gt;&gt;&gt; post1.tags.add(tag1)
    &gt;&gt;&gt; Tag.objects.filter(post=post1.pk)
    &lt;QuerySet [&lt;Tag: tag1&gt;]&gt;
    &gt;&gt;&gt; tags_list = Tag.objects.filter(post=OuterRef(&#39;pk&#39;))
    &gt;&gt;&gt; Post.objects.annotate(count=Subquery(tags_list.count()))

The last two lines should give me number of tags for each Post object. And here I keep getting the same error:

    ValueError: This queryset contains a reference to an outer query and may only be used in a subquery.

Content Type	Original Author	Original Content on Stackoverflow
Question	Alejandro Veintimilla	View Question on Stackoverflow
Solution 1 - Django	knbk	View Answer on Stackoverflow
Solution 2 - Django	Cameron Lee	View Answer on Stackoverflow
Solution 3 - Django	Manan Mehta	View Answer on Stackoverflow

Django Query __isnull=True or = None

Django Problem Overview

Django Solutions

Solution 1 - Django

Solution 2 - Django

Solution 3 - Django

What does FragmentManager and FragmentTransaction exactly do?

ES6 modules: Export single class of static methods OR multiple individual methods

Attributions