def backwards(self, orm):
     db.drop_primary_key("cmsplugin_picturepublic")
     db.rename_column("cmsplugin_picturepublic", "cmspluginpublic_ptr_id", "publiccmsplugin_ptr_id")
     db.create_primary_key("cmsplugin_picturepublic", ("publiccmsplugin_ptr_id",))
     db.rename_table("cmsplugin_picture", "picture_picture")
     db.rename_table("cmsplugin_picturepublic", "picture_publicpicture")
     db.alter_column('cmsplugin_picture', 'public_id', orm['picture.picture:public'])

 def forwards(self, orm):    
     db.rename_table("text_text", "cmsplugin_text")
     db.rename_table("text_publictext", "cmsplugin_textpublic")
     db.alter_column('cmsplugin_text', 'public_id', orm['text.text:public'])
     db.drop_primary_key("cmsplugin_textpublic")
     db.rename_column("cmsplugin_textpublic", "publiccmsplugin_ptr_id", "cmspluginpublic_ptr_id")
     db.create_primary_key("cmsplugin_textpublic", ("cmspluginpublic_ptr_id",))

    def test_primary_key(self):
        """
        Test the primary key operations
        """

        # SQLite backend doesn't support this yet.
        if db.backend_name == "sqlite3":
            return

        db.create_table(
            "test_pk",
            [
                ("id", models.IntegerField(primary_key=True)),
                ("new_pkey", models.IntegerField()),
                ("eggs", models.IntegerField(unique=True)),
            ],
        )
        db.execute_deferred_sql()
        # Remove the default primary key, and make eggs it
        db.drop_primary_key("test_pk")
        db.create_primary_key("test_pk", "new_pkey")
        # Try inserting a now-valid row pair
        db.execute("INSERT INTO test_pk (id, new_pkey, eggs) VALUES (1, 2, 3)")
        db.execute("INSERT INTO test_pk (id, new_pkey, eggs) VALUES (1, 3, 4)")
        db.delete_table("test_pk")

    def forwards(self, orm):
        "Make remote_id Primary Key"

        # Remove PK from Album
        db.delete_foreign_key('vkontakte_photos_photo', 'album_id')

        photos = orm.Photo.objects.only('album').all()  #

        for p in photos:
            album = orm.Album.objects.get(id=p.album_id)
            p.album_id = album.remote_id
            p.save()

        db.delete_primary_key('vkontakte_photos_album')
        #db.delete_column(u'vkontakte_photos_album', u'id')

        db.create_primary_key('vkontakte_photos_album', ['remote_id'])
        db.alter_column('vkontakte_photos_photo', 'album_id', models.ForeignKey(
            orm['vkontakte_photos.Album'], null=True, blank=True))

        # Remove PK from Photo
        # Remove Foreign key from Comments and likes
        db.delete_foreign_key('vkontakte_photos_comment', 'photo_id')
        db.delete_foreign_key('vkontakte_photos_photo_like_users', 'photo_id')

        db.delete_primary_key('vkontakte_photos_photo')
        #db.delete_column(u'vkontakte_photos_photo', u'id')

        # Create Primary Keys
        db.create_primary_key('vkontakte_photos_photo', ['remote_id'])

    def backwards(self, orm):
        # Deleting field 'Subsite.id'
        db.delete_column(u'brainstorm_subsite', u'id')


        # Changing field 'Subsite.slug'
        db.alter_column(u'brainstorm_subsite', 'slug', self.gf('django.db.models.fields.SlugField')(max_length=50, primary_key=True))
        # Adding primary key on 'Subsite', fields ['slug']
        db.create_primary_key(u'brainstorm_subsite', ['slug'])

    def backwards(self, orm):
        
        # Deleting field 'Rating.id'
        db.delete_column('cg_channel_rating', 'id')
        
        db.delete_index('cg_channel_rating', 'user_id')
        db.delete_index('cg_channel_rating', 'channel_id')

        db.create_primary_key('cg_channel_rating', ('channel_id', 'user_id'))

 def backwards(self, orm): 
     db.delete_foreign_key('cmsplugin_text' ,'public_id')
     db.drop_primary_key("cmsplugin_textpublic")
     
     db.rename_column("cmsplugin_textpublic", "cmspluginpublic_ptr_id", "publiccmsplugin_ptr_id")
     db.create_primary_key("cmsplugin_textpublic", ("publiccmsplugin_ptr_id",))      
     db.foreign_key_sql('cmsplugin_text' ,'public_id', 'cmsplugin_textpublic', "publiccmsplugin_ptr_id")
     db.rename_table("cmsplugin_text", "text_text")
     db.rename_table("cmsplugin_textpublic", "text_publictext")
     db.alter_column('cmsplugin_text', 'public_id', orm['text.text:public'])

 def backwards(self, orm):
     drop_tko_perf_view = """
     DROP VIEW IF EXISTS tko_perf_view
     """
     db.execute(drop_tko_perf_view)
     drop_tko_perf_view_2 = """
     DROP VIEW IF EXISTS tko_perf_view_2
     """
     db.execute(drop_tko_perf_view_2)
     db.delete_index('tko_iteration_result', 'test_idx')
     db.create_primary_key('tko_iteration_result', ['test_idx'])

    def forwards(self, orm):
        # Changing field 'AssetCategory.id' (serial)
        # to 'AssetCategory.slug' (slugfield)
        db.add_column('ralph_assets_assetcategory', 'slug',
                      self.gf('django.db.models.fields.SlugField')(default='slug',
                      unique=False, max_length=100),
                      keep_default=False)
        db.add_column('ralph_assets_asset', 'category_new_id',
                      self.gf('django.db.models.fields.SlugField')(null=True,
                      unique=False, max_length=100, db_index=False))
        db.add_column('ralph_assets_assetcategory', 'parent_new_id',
                      self.gf('django.db.models.fields.SlugField')(null=True,
                      unique=False, max_length=100, db_index=False))
        db.add_column('ralph_assets_assetmodel', 'category_new_id',
                      self.gf('django.db.models.fields.SlugField')(null=True,
                      unique=False, max_length=100, db_index=False))

        db.start_transaction()

        for id in db.execute(
            'SELECT id FROM ralph_assets_assetcategory WHERE parent_id IS NULL'):
            self.update_slug_and_child(id)

        db.commit_transaction()

        db.create_unique(u'ralph_assets_assetcategory', ['slug'])
        db.delete_foreign_key("ralph_assets_asset", "category_id")
        db.delete_foreign_key("ralph_assets_assetmodel", "category_id")
        db.delete_foreign_key("ralph_assets_assetcategory", "parent_id")
        db.delete_column('ralph_assets_assetcategory', 'parent_id')
        db.delete_column('ralph_assets_assetcategory', 'id')
        db.create_primary_key("ralph_assets_assetcategory", ["slug"])
        db.send_create_signal('ralph_assets', ['ralph_assets_assetcategory'])
        db.rename_column('ralph_assets_assetcategory', 'parent_new_id', 'parent_id')
        db.delete_column('ralph_assets_asset', 'category_id')
        db.rename_column('ralph_assets_asset', 'category_new_id', 'category_id')
        db.delete_column('ralph_assets_assetmodel', 'category_id')
        db.rename_column('ralph_assets_assetmodel', 'category_new_id', 'category_id')
        db.create_index('ralph_assets_assetcategory', ['parent_id'], unique=False)
        db.create_index('ralph_assets_asset', ['category_id'], unique=False)
        db.create_index('ralph_assets_assetmodel', ['category_id'], unique=False)
        sql = db.foreign_key_sql('ralph_assets_asset',
            'category_id', 'ralph_assets_assetcategory', 'slug')
        db.execute(sql)
        sql = db.foreign_key_sql('ralph_assets_assetmodel',
            'category_id', 'ralph_assets_assetcategory', 'slug')
        db.execute(sql)
        sql = db.foreign_key_sql('ralph_assets_assetcategory',
            'parent_id', 'ralph_assets_assetcategory', 'slug')
        db.execute(sql)
        try:
            db.delete_unique('ralph_assets_assetcategory', ['name'])
        except ValueError:
            pass

 def backwards(self, orm):
     try:
         db.delete_foreign_key("cmsplugin_file", "public_id")
     except:
         pass
     db.drop_primary_key("cmsplugin_filepublic")
     db.rename_column("cmsplugin_filepublic", "cmspluginpublic_ptr_id", "publiccmsplugin_ptr_id")
     db.create_primary_key("cmsplugin_filepublic", ("publiccmsplugin_ptr_id",))
     db.rename_table("cmsplugin_file", "file_file")
     db.rename_table("cmsplugin_filepublic", "file_publicfile")
     db.alter_column("file_file", "public_id", orm["file.file:public"])

    def backwards(self, orm):
        # Removing unique constraint on 'LeaderboardStanding', fields ['ranking', 'metric']
        db.delete_unique(u'links_leaderboardstanding', ['ranking', 'metric'])

        # Deleting field 'LeaderboardStanding.id'
        db.delete_column(u'links_leaderboardstanding', u'id')


        # Changing field 'LeaderboardStanding.ranking'
        db.alter_column(u'links_leaderboardstanding', 'ranking', self.gf('django.db.models.fields.PositiveIntegerField')(primary_key=True))
        # Adding primary key index on 'LeaderboardStanding', fiels['ranking']
        db.create_primary_key(u'links_leaderboardstanding', [u'ranking'])

 def forwards(self, orm):
     db.rename_table("text_text", "cmsplugin_text")
     db.rename_table("text_publictext", "cmsplugin_textpublic")
     db.rename_column("cmsplugin_textpublic", "publiccmsplugin_ptr_id", "cmspluginpublic_ptr_id")
     db.alter_column("cmsplugin_text", "public_id", orm["text.text:public"])
     try:
         db.delete_foreign_key("cmsplugin_text", "public_id")
     except:
         pass
     db.drop_primary_key("cmsplugin_textpublic")
     db.create_primary_key("cmsplugin_textpublic", ("cmspluginpublic_ptr_id",))
     db.foreign_key_sql("cmsplugin_text", "public_id", "cmsplugin_textpublic", "cmspluginpublic_ptr_id")

 def forwards(self, orm):
     
     db.rename_table("file_file", "cmsplugin_file")
     db.rename_table("file_publicfile", "cmsplugin_filepublic")
     db.alter_column('cmsplugin_file', 'public_id', orm['file.file:public'])
     try:
         db.delete_foreign_key('cmsplugin_file' ,'public_id')
     except:
         pass
     db.drop_primary_key("cmsplugin_filepublic")
     db.rename_column("cmsplugin_filepublic", "publiccmsplugin_ptr_id", "cmspluginpublic_ptr_id")
     db.create_primary_key("cmsplugin_filepublic", ("cmspluginpublic_ptr_id",))
     db.foreign_key_sql('cmsplugin_file' ,'public_id', 'cmsplugin_filepublic', 'cmspluginpublic_ptr_id')

 def forwards(self, orm):
     if not table_exists('microsite_microsite'):
         # Adding model 'MicroSite'
         db.create_table('microsite_microsite', (
             ('basesection_ptr', self.gf('django.db.models.fields.related.OneToOneField')(to=orm['section.BaseSection'], unique=True, primary_key=True)),
         ))
         db.send_create_signal('microsite', ['MicroSite'])
     else:
         db.delete_primary_key('microsite_microsite')
         db.create_primary_key('microsite_microsite', ['basesection_ptr_id'])
         db.delete_column('microsite_microsite', 'section_ptr_id')
         db.alter_column('microsite_microsite', 'basesection_ptr_id', models.ForeignKey(orm['section.BaseSection'], null=False, blank=False))
         db.delete_table('section_section')

    def forwards(self, orm):
        # OMFG Get ready, we're going to change the primary key!
        # Doing bad things, disabling triggers
        db.execute("ALTER TABLE brainstorm_idea DISABLE TRIGGER ALL;")

        # Dropping foreign key constraint
        db.delete_foreign_key('brainstorm_idea', 'subsite_id')
        db.execute('DROP INDEX brainstorm_idea_subsite_id_like')
        db.delete_index('brainstorm_idea', ['subsite_id'])

        # Removing primary key on 'Subsite', fields ['slug']
        db.delete_primary_key(u'brainstorm_subsite')

        # Adding primary key field 'Subsite.id'
        db.add_column(u'brainstorm_subsite', u'id',
                      self.gf('django.db.models.fields.IntegerField')(blank=True, null=True))

        # WOW. Have to manually create AutoFields. Thanks Django!
        db.execute('CREATE SEQUENCE brainstorm_subsite_id_seq;')
        db.execute("UPDATE brainstorm_subsite SET id = nextval('brainstorm_subsite_id_seq');")
        db.execute("ALTER TABLE brainstorm_subsite ALTER COLUMN id SET DEFAULT nextval('brainstorm_subsite_id_seq');")
        db.execute('ALTER SEQUENCE brainstorm_subsite_id_seq OWNED BY brainstorm_subsite.id;')
        db.execute("SELECT setval('brainstorm_subsite_id_seq', q.i) FROM(SELECT MAX(id) i FROM brainstorm_subsite) q;")

        # Now make it the pk
        db.create_primary_key('brainstorm_subsite', ['id'])

        # Updating foreign key values
        db.execute('''UPDATE brainstorm_idea idea
                      SET subsite_id = subsite.id
                      FROM brainstorm_subsite subsite
                      WHERE(idea.subsite_id = subsite.slug);''')

        # Casting the fk to an integer
        db.execute("ALTER TABLE brainstorm_idea ALTER COLUMN subsite_id TYPE integer USING CAST(subsite_id AS integer);")

        # Re-adding foreign key constraint
        fk_sql = db.foreign_key_sql('brainstorm_idea', 'subsite_id', 'brainstorm_subsite', 'id')
        db.execute(fk_sql)

        # Changing field 'Subsite.slug' to a plain old slugfield
        db.alter_column(u'brainstorm_subsite', 'slug', self.gf('django.db.models.fields.SlugField')(max_length=50))

        # Adding unique constraint on 'Subsite', fields ['slug']
        db.create_unique(u'brainstorm_subsite', ['slug'])

        # Re-enabling triggers
        db.execute("ALTER TABLE brainstorm_idea ENABLE TRIGGER ALL;")

    def backwards(self, orm):
        db.rename_column('pricing_volume_type_resource', 'resource_ptr_id', 'resource_id')
        db.delete_column('pricing_volume_type_resource', u'id')
        db.alter_column('pricing_volume_type_resource', 'os_volume_type_id', self.gf('django.db.models.fields.CharField')(unique=True, max_length=36, db_index=False))
        db.delete_index('pricing_volume_type_resource', ['os_volume_type_id'])
        db.rename_column('pricing_volume_type_resource', 'os_volume_type_id', 'os_type_id')
        db.create_primary_key('pricing_volume_type_resource', ['os_type_id'])
        db.add_column('pricing_volume_type_resource', 'description', self.gf('django.db.models.fields.CharField')(max_length=100))

        db.alter_column('pricing_instance_flavor_resource', 'id', self.gf('django.db.models.fields.IntegerField')(primary_key=True))
        db.delete_index('pricing_instance_flavor_resource', ['os_instance_type_id'])
        db.rename_column('pricing_instance_flavor_resource', 'os_instance_type_id', 'os_flavor_id')
        db.rename_column('pricing_instance_flavor_resource', 'resourcebase_ptr_id', 'resource_id')
        db.alter_column('pricing_instance_flavor_resource', 'resource_id', self.gf('django.db.models.fields.IntegerField')(blank=False))
        db.delete_column('pricing_instance_flavor_resource', u'id')
        db.create_primary_key('pricing_instance_flavor_resource', ['os_flavor_id'])
        db.add_column('pricing_instance_flavor_resource', 'description', self.gf('django.db.models.fields.CharField')(max_length=100))

 def test_primary_key(self):
     """
     Test the primary key operations
     """
     
     db.create_table("test_pk", [
         ('id', models.IntegerField(primary_key=True)),
         ('new_pkey', models.IntegerField()),
         ('eggs', models.IntegerField(unique=True)),
     ])
     db.execute_deferred_sql()
     # Remove the default primary key, and make eggs it
     db.delete_primary_key("test_pk")
     db.create_primary_key("test_pk", "new_pkey")
     # Try inserting a now-valid row pair
     db.execute("INSERT INTO test_pk (id, new_pkey, eggs) VALUES (1, 2, 3)")
     db.execute("INSERT INTO test_pk (id, new_pkey, eggs) VALUES (1, 3, 4)")
     db.delete_table("test_pk")

 def test_primary_key(self):
     """
     Test the primary key operations
     """
     db.create_table(
         "test_pk",
         [
             ("id", models.IntegerField(primary_key=True)),
             ("new_pkey", models.IntegerField()),
             ("eggs", models.IntegerField(unique=True)),
         ],
     )
     db.execute_deferred_sql()
     db.start_transaction()
     # Remove the default primary key, and make eggs it
     db.drop_primary_key("test_pk")
     db.create_primary_key("test_pk", "new_pkey")
     # Try inserting a now-valid row pair
     db.execute("INSERT INTO test_pk (id, new_pkey, eggs) VALUES (1, 2, 3), (1, 3, 4)")
     db.rollback_transaction()
     db.delete_table("test_pk")

    def forwards(self, orm):
        # Deleting field 'BaseSection.status'
        db.delete_column('section_basesection', 'status')

        # Deleting field 'BaseSection.slug'
        db.delete_column('section_basesection', 'slug')

        # Deleting field 'BaseSection.main_image'
        db.delete_column('section_basesection', 'main_image')

        # Deleting field 'BaseSection.id'
        db.delete_column('section_basesection', 'id')

        for field in ('name', 'description', 'plain_description', ):
            for lang, lang_name in settings.LANGUAGES:
                db.delete_column('section_basesection', get_real_fieldname(field, lang))

        # Swapping primary key from id to basecontent_ptr_id
        db.create_primary_key('section_basesection', ['basecontent_ptr_id'])

        # Add new foreign key to section_basesection_related_content.basesection_id
        db.alter_column('section_basesection_related_content', 'basesection_id', models.ForeignKey(orm['section.BaseSection'], null=False, blank=False))

    def forwards(self, orm):
        # create assessment answer model
        db.create_table(u'scorystapp_submission', (
            (u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('assessment', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['scorystapp.Assessment'])),
            ('course_user1', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['scorystapp.CourseUser'], null=True, blank=True)),
            ('released1', self.gf('django.db.models.fields.BooleanField')(default=False)),
            ('page_count1', self.gf('django.db.models.fields.IntegerField')()),
            ('pdf1', self.gf('django.db.models.fields.files.FileField')(max_length=100))
        ))
        db.send_create_signal(u'scorystapp', ['Submission'])

        # add submission_ptr field for primary key
        db.add_column(u'scorystapp_examanswer', 'submission_ptr',
                      self.gf('django.db.models.fields.related.ForeignKey')(to=orm['scorystapp.Submission'], null=True),
                      keep_default=False)

        # create assessment that corresponds to each exam
        db.start_transaction()
        for exam_answer in orm.ExamAnswer.objects.all():
            submission = orm.Submission(id=exam_answer.id, course_user1=exam_answer.course_user,
                released1=exam_answer.released, assessment=exam_answer.exam, page_count1=exam_answer.page_count,
                pdf1=exam_answer.pdf)
            submission.save()

            exam_answer.submission_ptr = submission
            exam_answer.save()
        db.commit_transaction()

        # convert submission_ptr_id to primary key
        db.create_unique(u'scorystapp_examanswer', ['submission_ptr_id'])
        db.delete_column(u'scorystapp_examanswer', u'id')
        db.create_primary_key(u'scorystapp_examanswer', [u'submission_ptr_id'])

        # delete exam answer columns that we put into assessment answer
        db.delete_column(u'scorystapp_examanswer', 'course_user_id')
        db.delete_column(u'scorystapp_examanswer', 'released')
        db.delete_column(u'scorystapp_examanswer', 'exam_id')