Fixed #24184 -- Prevented automatic soft-apply of migrations

                'Defaults to the "default" database.')

        parser.add_argument('--fake', action='store_true', dest='fake', default=False,

            help='Mark migrations as run without actually running them')

        parser.add_argument('--fake-initial', action='store_true', dest='fake_initial', default=False,

            help='Detect if tables already exist and fake-apply initial migrations if so. Make sure '

                 'that the current database schema matches your initial migration before using this '

                 'flag. Django will only check for an existing table name.')

        parser.add_argument('--list', '-l', action='store_true', dest='list', default=False,

            help='Show a list of all known migrations and which are applied')

                        "apply them."

                    ))

        else:

            executor.migrate(targets, plan, fake=options.get("fake", False))

            fake = options.get("fake")

            fake_initial = options.get("fake_initial")

            executor.migrate(targets, plan, fake=fake, fake_initial=fake_initial)

        # Send the post_migrate signal, so individual apps can do whatever they need

        # to do at this point.

                        applied.add(migration)

        return plan

    def migrate(self, targets, plan=None, fake=False):

    def migrate(self, targets, plan=None, fake=False, fake_initial=False):

        """

        Migrates the database up to the given targets.

        # Phase 2 -- Run the migrations

        for migration, backwards in plan:

            if not backwards:

                self.apply_migration(states[migration], migration, fake=fake)

                self.apply_migration(states[migration], migration, fake=fake, fake_initial=fake_initial)

            else:

                self.unapply_migration(states[migration], migration, fake=fake)

            statements.extend(schema_editor.collected_sql)

        return statements

    def apply_migration(self, state, migration, fake=False):

    def apply_migration(self, state, migration, fake=False, fake_initial=False):

        """

        Runs a migration forwards.

        """

        if self.progress_callback:

            self.progress_callback("apply_start", migration, fake)

        if not fake:

            if fake_initial:

                # Test to see if this is an already-applied initial migration

                applied, state = self.detect_soft_applied(state, migration)

                if applied:

                    fake = True

            else:

            if not fake:

                # Alright, do it normally

                with self.connection.schema_editor() as schema_editor:

                    state = migration.apply(state, schema_editor)

table into a state where manual recovery will be needed to make migrations

run correctly.

.. versionadded:: 1.8

.. django-admin-option:: --fake-initial

The ``--fake-initial`` option can be used to allow Django to skip an app's

initial migration if all database tables with the names of all models created

by all :class:`~django.db.migrations.operations.CreateModel` operations in that

migration already exist. This option is intended for use when first running

migrations against a database that preexisted the use of migrations. This

option does not, however, check for matching database schema beyond matching

table names and so is only safe to use if you are confident that your existing

schema matches what is recorded in your initial migration.

.. deprecated:: 1.8

    The ``--list`` option has been moved to the :djadmin:`showmigrations`

  has been removed by a migration and replaced by a property. That means it's

  not possible to query or filter a ``ContentType`` by this field any longer.

* :djadmin:`migrate` now accepts the :djadminopt:`--fake-initial` option to

  allow faking initial migrations. In 1.7 initial migrations were always

  automatically faked if all tables created in an initial migration already

  existed.

.. _deprecated-features-1.8:

Features deprecated in 1.8

get both the changes to your models and the accompanying migration at the

same time.

.. versionadded:: 1.8

If you want to give the migration(s) a meaningful name instead of a generated

one, you can use the :djadminopt:`--name` option::

    $ python manage.py makemigrations --name changed_my_model your_app_label

Version control

~~~~~~~~~~~~~~~

    $ python manage.py makemigrations your_app_label

This will make a new initial migration for your app. Now, when you run

:djadmin:`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.

This will make a new initial migration for your app. Now, run ``python

manage.py migrate --fake-initial``, and 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. (Without the

:djadminopt:`--fake-initial` flag, the :djadmin:`migrate` command would error

out because the tables it wants to create already exist.)

Note that this only works given two things:

  that your database doesn't match your models, you'll just get errors when

  migrations try to modify those tables.

.. versionadded:: 1.8

If you want to give the migration(s) a meaningful name instead of a generated one,

you can use the :djadminopt:`--name` option::

.. versionchanged: 1.8

    $ python manage.py makemigrations --name changed_my_model your_app_label

    The ``--fake-initial`` flag to :djadmin:`migrate` was added. Previously,

    Django would always automatically fake-apply initial migrations if it

    detected that the tables exist.

.. _historical-models:

  ``__init__.py`` - make sure you remove the ``.pyc`` files too.

* Run ``python manage.py makemigrations``. Django should see the empty

  migration directories and make new initial migrations in the new format.

* Run ``python manage.py migrate``. Django will see that the tables for the

  initial migrations already exist and mark them as applied without running

  them.

* Run ``python manage.py migrate --fake-initial``. Django will see that the

  tables for the initial migrations already exist and mark them as applied

  without running them. (Django won't check that the table schema match your

  models, just that the right table names exist).

That's it! The only complication is if you have a circular dependency loop

of foreign keys; in this case, ``makemigrations`` might make more than one

    python manage.py migrate --fake yourappnamehere

.. versionchanged:: 1.8

    The :djadminopt:`--fake-initial` flag was added to :djadmin:`migrate`;

    previously, initial migrations were always automatically fake-applied if

    existing tables were detected.

Libraries/Third-party Apps

~~~~~~~~~~~~~~~~~~~~~~~~~~