python – Django 1.7 – "No migrations to apply" when run migrate after makemigrations-ThrowExceptions

Exception or error:

I use Django1.7 with Mezzanine. I create simple profile (according to Mezzanine documentation) stored in separate app “profiles”:

class RoadmapProfile(models.Model):
    user = models.OneToOneField("auth.User")
    fullname = models.CharField(max_length=100, verbose_name="Full name")

Creation of migrations returns:

  Migrations for 'profiles':
        - Create model RoadmapProfile

When I run “migrate profiles”:

Operations to perform:
  Apply all migrations: profiles
Running migrations:
  No migrations to apply.

The issue is, when I try to open any page related to mezzanine.accounts (for example update account), it crashes with:

OperationalError at /accounts/update/

no such column: profiles_roadmapprofile.fullname

What I have done wrong?

How to solve:

Sounds like your initial migration was faked because the table already existed (probably with an outdated schema):

“This will make a new initial migration for your app. Now, when you
run migrate, Django will detect that you have an initial migration and
that the tables it wants to create already exist, and will mark the
migration as already applied

Otherwise you would get an no-such-table error ­čÖé

[edit] did you clean up the applied-migrations table? That’s also a common cause for non-applied migrations.


  1. In MySQL Database delete row 'profiles' from the table 'django_migrations'.
  2. Delete all migration files in migrations folder.
  3. Try again python makemigrations and python migrate command.


I am a Django newbie and I was going through the same problem. These answers didn’t work for me. I wanted to share how did I fix the problem, probably it would save someone lots of time.


I make changes to a model and I want to apply these changes to the DB.

What I did:

Run on shell:

python makemigrations app-name
python migrate app-name

What happened:

  • No changes are made in the DB

  • But when I check the db schema, it remains to be the old one


  • When I run python migrate app-name, Django checks in django_migrations table in the db to see which migrations have been already applied and will skip those migrations.

What I tried:

Delete the record with app=”my-app-name” from that table (delete from django_migrations where app = "app-name"). Clear my migration folder and run python makemigration my-app-name, then python migrate my-app-name. This was suggested by the most voted answer. But that doesn’t work either.


Because there was an existing table, and what I am creating was a “initial migration”, so Django decides that the initial migration has already been applied (Because it sees that the table already exists). The problem is that the existing table has a different schema.

Solution 1:

Drop the existing table (with the old schema), make initial migrations, and applied again. This will work (it worked for me) since we have an “initial migration” and there was no table with the same name in our db. (Tip: I used python migrate my-app-name zero to quickly drop the tables in the db)

Problem? You might want to keep the data in the existing table. You don’t want to drop them and lose all of the data.

Solution 2:

  1. Create an initial migration with the same schema as the existing table, with these steps:

    • Modify your to match with the current table in your database

    • Delete all files in “migrations”

    • Run python makemigrations your-app-name

  2. Delete in django_migrations all the fields with = your-app-name
    How to do this depends on which DB you are using
    Example for MySQL: delete from django_migrations where app = "your-app-name";

  3. Modify your to match the new schema (e.i. the schema that you need now)

  4. Make new migration by running python makemigrations your-app-name

  5. Run python migrate your-app-name

This works for me. And I managed to keep the existing data.

More thoughts:

The reason I went through all of those troubles was that I deleted the files in some-app/migrations/ (the migrations files). And hence, those migration files and my database aren’t consistent with one another. So I would try not modifying those migration files unless I really know what I am doing.


1- run python makemigrations <appname>

2- run python sqlmigrate <appname> <migrationname> – you will find migrationname in migration folder under appname (without ‘.py’ extension of course)

3- copy all text of result # all sql commands that generated
4- go to your db ide and paste as new query and run it

now all changes are applied on your db


python migrate --fake APPNAME zero

This will make your migration to fake. Now you can run the migrate script

python migrate APPNAME

Tables will be created and you solved your problem.. Cheers!!!


In my case I wrote like this:

python makemigrations –empty yourappname

python migrate yourappname


Django keeps track of all the applied migrations in django_migrations table. So just delete all the rows in the django_migrations table that are related to you app like:

DELETE FROM django_migrations WHERE app='your-app-name'

and then do:

python makemigrations
python migrate


The problem here are fake migrations somewhere. Basically in your database the table created from your model doesn’t exist, tho somewhere in time that table existed before, due an old update o whatever it may be. The problem is that django already made those migrations so the tables MUST exist for hence overlooking migrations but getting error “table_doesnt_exist” in Admin.


1.- Make sure to save any data from that model.

2.- Access your database and run this query.

 SELECT * FROM django_migrations;

3.- Get the id from the list generated from the query. These are migrations that Django has migrated so far, hence TABLES MUST EXIST. In your case I’d look for a row named roadmapprofile, due this is the name of your model.

4.- Now lets delete this row from this table using the ids,

 DELETE FROM django_migrations where in (value_id1, value_id2 ... value_idN);

Replace value_id1 and value_id2 with respective ids. It could be only one or many so don’t worry if you don’t see more than 1 id, what this means is that only one model exists under the current app.

5.- Migrate app to zero migrate <app_name> zero

6.- Delete all migrations files within the app migrations folder

7.- Create Migrations makemigrations

8.- Once you delete these registries and run migrate; Django will be forced to run migrations for these models due “MIGRATIONS WON’T EXIST” for these models. migrate

That’s it. You shouldn’t have any problems following these instructions. By the way, you shouldn’t loose any data from other models due you’re only migrating and updating tables related to these specific models.


My issue was that there was no file in the same folder as the migrations. On adding the to the folder which contained them, migrate found and ran them.


@phanhuy152 has the best answer. Just to add my two cents:

His solution is:

  1. Delete migration history in DB
  2. Delete migrations folder
  3. Edit your model to be consistent with DB before your change
  4. makemigrations to restore the initial state of the migration files
  5. Then, change the model as you like
  6. makemigrations again
  7. migrate to apply updates to table.

But in my case, I have several models in the file and at the last step, Django complains about Table xxx already exists, because the initial migrations files intends to create the xxx table again, when we just don’t (and don’t want to)drop other tables.

In this case, in order to preserve the data, we must tell Django to leave them alone in migrate. We just do: (assume that class A is the one we change, and class B, C remain same):

from django.db import models

class A(models.Models):

class B(models.Models):
    class Meta:
        managed = False   # tell Django to leave this class alone


class C(models.Models):
    class Meta:
        managed = False   # tell Django to leave this class alone

Add these lines after we construct the initial migrations.

So, the process now is:

  1. Add managed = False to other classes
  2. makemigrations to apply Meta changes. You will see something like:


Migrations for 'backEnd':
    - Change Meta options on toid
    - Change Meta options on tprocessasinc
    - Change Meta options on tservers
    - Change Meta options on tsnmpserver
  1. migrate to apply them in DB
  2. Change your model now: add a field, change the type, etc.
  3. migrate again.
  4. Delete the Meta class to let Django manage other class again. makemigrations, migrate again.

Now you have all the structure and data of your models, without losing the part formerly stored in DB.


I had this same problem. Make sure the app’s migrations folder is created (YOURAPPNAME/ migrations). Delete the folder and enter the commands:

python migrate --fake
python makemigrations <app_name>
python migrate --fake-initial

I inserted this lines in each class in

class Meta:
    app_label = '<app_name>'

This solved my problem.


For me, none of the offered solutions worked. It turns out that I was using different settings for migration ( and running ( Settings defined in used a local database however a production database was used in settings. Thus a production database was never migrated.

django-admin migrate

for migration proved to be better as you have to specify the settings used as here.

  • Make sure that when migrating you always use the same database as
    when running!


Maybe your model not linked when migration process is ongoing.
Try to import it in file from models import your_file

Leave a Reply

Your email address will not be published. Required fields are marked *