[1.8.x] Added a helper function in schema tests.

        with connection.cursor() as cursor:

            return connection.introspection.get_constraints(cursor, table)

    def get_constraints_for_column(self, model, column_name):

        constraints = self.get_constraints(model._meta.db_table)

        constraints_for_column = []

        for name, details in constraints.items():

            if details['columns'] == [column_name]:

                constraints_for_column.append(name)

        return sorted(constraints_for_column)

    # Tests

    def test_creation_deletion(self):

    @unittest.skipUnless(connection.vendor == 'postgresql', "PostgreSQL specific")

    def test_alter_field_add_index_to_charfield(self):

        # Create the table

        # Create the table and verify no initial indexes.

        with connection.schema_editor() as editor:

            editor.create_model(Author)

        # Ensure the table is there and has no index

        self.assertNotIn('name', self.get_indexes(Author._meta.db_table))

        # Alter to add the index

        self.assertEqual(self.get_constraints_for_column(Author, 'name'), [])

        # Alter to add db_index=True and create 2 indexes.

        old_field = Author._meta.get_field('name')

        new_field = CharField(max_length=255, db_index=True)

        new_field.set_attributes_from_name('name')

        with connection.schema_editor() as editor:

            editor.alter_field(Author, old_field, new_field, strict=True)

        # Check that all the constraints are there

        constraints = self.get_constraints(Author._meta.db_table)

        name_indexes = []

        for name, details in constraints.items():

            if details['columns'] == ['name']:

                name_indexes.append(name)

        self.assertEqual(2, len(name_indexes), 'Indexes are missing for name column')

        name_indexes = self.get_constraints_for_column(Author, 'name')

        self.assertEqual(len(name_indexes), 2)

        # Check that one of the indexes ends with `_like`

        like_index = [x for x in name_indexes if x.endswith('_like')]

        self.assertEqual(1, len(like_index), 'Index with the operator class is missing for the name column')

        # Remove the index

        # Remove db_index=True to drop both indexes.

        with connection.schema_editor() as editor:

            editor.alter_field(Author, new_field, old_field, strict=True)

        # Ensure the name constraints where dropped

        constraints = self.get_constraints(Author._meta.db_table)

        name_indexes = []

        for details in constraints.values():

            if details['columns'] == ['name']:

                name_indexes.append(details)

        self.assertEqual(0, len(name_indexes), 'Indexes were not dropped for the name column')

        self.assertEqual(self.get_constraints_for_column(Author, 'name'), [])

    @unittest.skipUnless(connection.vendor == 'postgresql', "PostgreSQL specific")

    def test_alter_field_add_index_to_textfield(self):

        # Create the table

        # Create the table and verify no initial indexes.

        with connection.schema_editor() as editor:

            editor.create_model(Note)

        # Ensure the table is there and has no index

        self.assertNotIn('info', self.get_indexes(Note._meta.db_table))

        # Alter to add the index

        self.assertEqual(self.get_constraints_for_column(Note, 'info'), [])

        # Alter to add db_index=True and create 2 indexes.

        old_field = Note._meta.get_field('info')

        new_field = TextField(db_index=True)

        new_field.set_attributes_from_name('info')

        with connection.schema_editor() as editor:

            editor.alter_field(Note, old_field, new_field, strict=True)

        # Check that all the constraints are there

        constraints = self.get_constraints(Note._meta.db_table)

        info_indexes = []

        for name, details in constraints.items():

            if details['columns'] == ['info']:

                info_indexes.append(name)

        self.assertEqual(2, len(info_indexes), 'Indexes are missing for info column')

        # Check that one of the indexes ends with `_like`

        info_indexes = self.get_constraints_for_column(Note, 'info')

        self.assertEqual(len(info_indexes), 2)

        like_index = [x for x in info_indexes if x.endswith('_like')]

        self.assertEqual(1, len(like_index), 'Index with the operator class is missing for the info column')

        # Remove the index

        self.assertEqual(1, len(like_index), 'Index with the operator class is missing for the name column')

        # Remove db_index=True to drop both indexes.

        with connection.schema_editor() as editor:

            editor.alter_field(Note, new_field, old_field, strict=True)

        # Ensure the info constraints where dropped

        constraints = self.get_constraints(Note._meta.db_table)

        info_indexes = []

        for details in constraints.values():

            if details['columns'] == ['info']:

                info_indexes.append(details)

        self.assertEqual(0, len(info_indexes), 'Indexes were not dropped for the info column')

        self.assertEqual(self.get_constraints_for_column(Note, 'info'), [])