def forwards(self, orm):
        # Adding model 'AddressRecord'
        db.create_table('address_record', (
            ('created', self.gf('django.db.models.fields.DateTimeField')(auto_now_add=True, blank=True)),
            ('modified', self.gf('django.db.models.fields.DateTimeField')(auto_now=True, blank=True)),
            ('ip_str', self.gf('django.db.models.fields.CharField')(max_length=39)),
            ('ip_upper', self.gf('django.db.models.fields.BigIntegerField')(null=True, blank=True)),
            ('ip_lower', self.gf('django.db.models.fields.BigIntegerField')(null=True, blank=True)),
            ('ip_type', self.gf('django.db.models.fields.CharField')(max_length=1)),
            ('domain', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['domain.Domain'])),
            ('label', self.gf('django.db.models.fields.CharField')(max_length=63, null=True, blank=True)),
            ('fqdn', self.gf('django.db.models.fields.CharField')(db_index=True, max_length=255, null=True, blank=True)),
            ('ttl', self.gf('django.db.models.fields.PositiveIntegerField')(default=3600, null=True, blank=True)),
            ('description', self.gf('django.db.models.fields.CharField')(max_length=1000, null=True, blank=True)),
            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
        ))
        db.send_create_signal('address_record', ['AddressRecord'])

        # Adding unique constraint on 'AddressRecord', fields ['label', 'domain', 'fqdn', 'ip_upper', 'ip_lower', 'ip_type']
        db.create_unique('address_record', ['label', 'domain_id', 'fqdn', 'ip_upper', 'ip_lower', 'ip_type'])

        # Adding M2M table for field views on 'AddressRecord'
        db.create_table('address_record_views', (
            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
            ('addressrecord', models.ForeignKey(orm['address_record.addressrecord'], null=False)),
            ('view', models.ForeignKey(orm['view.view'], null=False))
        ))
        db.create_unique('address_record_views', ['addressrecord_id', 'view_id'])
        db.execute_many(open("cyder/cydns/address_record/sql/addressrecord.sql").read())

    def forwards(self, orm):
        # Adding model 'PTR'
        db.create_table('ptr', (
            ('ip_str', self.gf('django.db.models.fields.CharField')(max_length=39)),
            ('ip_upper', self.gf('django.db.models.fields.BigIntegerField')(null=True, blank=True)),
            ('ip_lower', self.gf('django.db.models.fields.BigIntegerField')(null=True, blank=True)),
            ('ip_type', self.gf('django.db.models.fields.CharField')(max_length=1)),
            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('reverse_domain', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['domain.Domain'], blank=True)),
            ('name', self.gf('django.db.models.fields.CharField')(max_length=255)),
            ('ttl', self.gf('django.db.models.fields.PositiveIntegerField')(default=3600, null=True, blank=True)),
            ('description', self.gf('django.db.models.fields.CharField')(max_length=1000, null=True, blank=True)),
        ))
        db.send_create_signal('ptr', ['PTR'])

        # Adding unique constraint on 'PTR', fields ['ip_str', 'ip_type', 'name']
        db.create_unique('ptr', ['ip_str', 'ip_type', 'name'])

        # Adding M2M table for field views on 'PTR'
        db.create_table('ptr_views', (
            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
            ('ptr', models.ForeignKey(orm['ptr.ptr'], null=False)),
            ('view', models.ForeignKey(orm['view.view'], null=False))
        ))
        db.create_unique('ptr_views', ['ptr_id', 'view_id'])
        db.execute_many(open("cyder/cydns/ptr/sql/ptr.sql").read())

    def forwards(self, orm):
        # Adding model 'Network'
        db.create_table('network', (
            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('vlan', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['vlan.Vlan'], null=True, on_delete=models.SET_NULL, blank=True)),
            ('site', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['site.Site'], null=True, on_delete=models.SET_NULL, blank=True)),
            ('ip_type', self.gf('django.db.models.fields.CharField')(max_length=1)),
            ('ip_upper', self.gf('django.db.models.fields.BigIntegerField')(blank=True)),
            ('ip_lower', self.gf('django.db.models.fields.BigIntegerField')(blank=True)),
            ('network_str', self.gf('django.db.models.fields.CharField')(max_length=49)),
            ('prefixlen', self.gf('django.db.models.fields.PositiveIntegerField')()),
            ('dhcpd_raw_include', self.gf('django.db.models.fields.TextField')(null=True, blank=True)),
        ))
        db.send_create_signal('network', ['Network'])

        # Adding unique constraint on 'Network', fields ['ip_upper', 'ip_lower', 'prefixlen']
        db.create_unique('network', ['ip_upper', 'ip_lower', 'prefixlen'])

        # Adding model 'NetworkKeyValue'
        db.create_table('network_kv', (
            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('key', self.gf('django.db.models.fields.CharField')(max_length=255)),
            ('value', self.gf('django.db.models.fields.CharField')(max_length=255)),
            ('is_quoted', self.gf('django.db.models.fields.BooleanField')(default=False)),
            ('is_option', self.gf('django.db.models.fields.BooleanField')(default=False)),
            ('is_statement', self.gf('django.db.models.fields.BooleanField')(default=False)),
            ('has_validator', self.gf('django.db.models.fields.BooleanField')(default=False)),
            ('network', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['network.Network'])),
        ))
        db.send_create_signal('network', ['NetworkKeyValue'])

        # Adding unique constraint on 'NetworkKeyValue', fields ['key', 'value', 'network']
        db.create_unique('network_kv', ['key', 'value', 'network_id'])
        db.execute_many(open("cyder/cydhcp/network/sql/network.sql").read())

    def forwards(self, orm):
        
        db.start_transaction()
        # Argh. The DB dump has a lot of crap we don't care about at all.
 
        # So, use South's fake ORM dictionary to figure out how to create those columns.
        db.add_column('gis_neighborhoods', 'stacked', orm['bmabr.neighborhood:stacked'])
        db.add_column('gis_neighborhoods', 'annoline1', orm['bmabr.neighborhood:annoline1']),
        db.add_column('gis_neighborhoods', 'annoline2', orm['bmabr.neighborhood:annoline2']),
        db.add_column('gis_neighborhoods', 'annoline3', orm['bmabr.neighborhood:annoline3']),
        db.add_column('gis_neighborhoods', 'annoangle', orm['bmabr.neighborhood:annoangle']), 
        db.commit_transaction()

        # Now load the data.
        db.start_transaction()
        HERE = os.path.abspath(os.path.dirname(__file__))
        sql_path = os.path.abspath(
            os.path.join(HERE, '..', '..', 'sql', 'gis_neighborhoods.sql'))
        db.execute_many(open(sql_path).read())
        db.execute("UPDATE gis_neighborhoods SET state = 'NY'")
        db.commit_transaction()

        # Now clean up the crap we don't want.
        db.start_transaction()
        db.delete_column('gis_neighborhoods', 'stacked')
        db.delete_column('gis_neighborhoods', 'annoangle')
        db.delete_column('gis_neighborhoods', 'annoline1')
        db.delete_column('gis_neighborhoods', 'annoline2')
        db.delete_column('gis_neighborhoods', 'annoline3')
        db.commit_transaction()

 def backwards(self, orm):
     db.execute_many('\n'.join(
         "ALTER TABLE {table_name} MODIFY COLUMN {column_name} timestamp NULL;".format(
             table_name=table_name,
             column_name=column_name,
         ) for table_name, column_name in TIMESTAMP_COLUMNS
     ))

 def forwards(self, orm):
     db.delete_foreign_key('fccpublicfiles_politicalbuy', 'publicdocument_ptr_id')
     db.rename_column('fccpublicfiles_politicalbuy', 'publicdocument_ptr_id', 'id')
     db.execute_many('''
         create sequence fccpublicfiles_politicalbuy_id_seq;
         select setval('fccpublicfiles_politicalbuy_id_seq', max(id)) from fccpublicfiles_publicdocument;
         alter table fccpublicfiles_politicalbuy alter column id set default nextval('fccpublicfiles_politicalbuy_id_seq');
     ''')

 def forwards(self, orm):
     curdir = os.path.dirname(os.path.abspath(__file__))
     sqldir = os.path.normpath(os.path.join(curdir, '..', '..', 'sql'))
     cityracks_path = os.path.join(sqldir, 'gis_cityracks.sql')
     f = open(cityracks_path)
     sql = f.read()
     f.close()
     db.execute_many(sql)

 def forwards(self, orm):
     if db.backend_name == 'mysql':
         db.execute_many("""
         ALTER DATABASE CHARACTER SET utf8 COLLATE utf8_general_ci;
         ALTER TABLE student_pendingemailchange CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
         ALTER TABLE student_pendingnamechange CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
         ALTER TABLE student_usertestgroup CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
         ALTER TABLE student_usertestgroup_users CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
         """)

    def forwards(self, orm):
        basepath = os.path.dirname(os.path.dirname(__file__))
        configsql = os.path.join(basepath, 'sql', 'configsection.sql')
        signaturesql = os.path.join(basepath, 'sql', 'domainsignature.sql')

        # configsection.sql
        db.execute_many(open(configsql).read())

        # domainsignature.sql
        db.execute_many(open(signaturesql).read())

 def forwards(self, orm):
     
     # Adding model 'NYCStreet'
     sql_path = os.path.abspath(
         os.path.join(HERE, '..', '..', 'data', 'shps', 'nyc_streets',
                      'gis_nycstreets.sql.gz'))
     import gzip
     z = gzip.GzipFile(sql_path)
     db.execute_many(z.read())
     db.send_create_signal('bmabr', ['NYCStreet'])

 def forwards(self, orm):
     SQLDIR = os.path.join(os.path.dirname(__file__),'..','sql')
     print "Sql directory: '%s'" % SQLDIR
     sqlfile = os.path.join(SQLDIR,'dbviews-mysql.sql')
     print "Sql file: '%s'" % sqlfile
     sql = open(sqlfile).read()
     print "Sql to execute: views: %s  lines: %s" % (sql.count('create or replace view'),  sql.count('\n'))
     db.execute_many(sql)
     #db.execute_many(sql, regex=r"(?mx) ([^';]* (?:'[^']*'[^';]*)*)", comment_regex=r"(?mx) (?:^\s*$)|(?:--.*$)") #remove comments        
     print "Sql executed!"

 def forwards(self, orm):
     "Make Course.id == Course.number"
     sql = """
         SET CONSTRAINTS ALL DEFERRED;
         UPDATE "courses_coursemark" SET "course_id"="number" 
           FROM "courses_course" 
           WHERE "courses_course"."id" = "course_id";
         UPDATE "courses_course" SET "id"="number";
     """
     db.execute_many(sql)

 def forwards(self, orm):
     "Write your forwards methods here."
     # Note: Remember to use orm['appname.ModelName'] rather than "from appname.models..."
     db.execute_many("""
     update fccpublicfiles_genericpublicdocument set is_visible = 't'; 
     update fccpublicfiles_politicalbuy set is_visible = 't'; 
     update fccpublicfiles_organization set is_visible = 't'; 
     update fccpublicfiles_politicalspot set is_visible = 't'; 
     update fccpublicfiles_role set is_visible = 't'; 
     update fccpublicfiles_person set is_visible = 't'; 
     """)

    def backwards(self, orm):
        # Adding field 'Domain.forward_canonical'
        db.add_column('domain', 'forward_canonical', orm['domain.domain:forward_canonical'])

        # Adding field 'Domain.alias'
        db.add_column('domain', 'alias', orm['domain.domain:alias'])

        # Adding field 'Domain.is_active'
        db.add_column('domain', 'is_active', orm['domain.domain:is_active'])

        # replace with original view
        db.execute_many(DB_VIEWS_BACKWARDS)

    def forwards(self, orm):
        
        #This is also done in a custom manner to workwith the latin1 varchar country foreign key
        #like im migration 0007
        db.execute_many("""
        CREATE TABLE `sqp_questionbulkassignments_users` (
            `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
            `questionbulkassignments_id` integer NOT NULL,
            `user_id` integer NOT NULL,
            UNIQUE (`questionbulkassignments_id`, `user_id`)
        ) ENGINE = InnoDB DEFAULT CHARSET = latin1;
        
        ALTER TABLE `sqp_questionbulkassignments_users` ADD CONSTRAINT `user_id_refs_id_
        178ee5d9` FOREIGN KEY (`user_id`) REFERENCES `auth_user` (`id`);
        """)
        
        db.execute("""
        CREATE TABLE `sqp_questionbulkassignments` (
            `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
            `study_id` integer NULL,
            `country_id` varchar(2) NULL,
            `language_id` integer NULL,
            `can_edit_text` bool NOT NULL,
            `can_edit_details` bool NOT NULL,
            `run_on_save` bool NOT NULL,
            `has_been_run` bool NOT NULL,
            `last_run_date` date NULL
        ) ENGINE = InnoDB DEFAULT CHARSET = latin1;
        """)
        
        db.execute("""
        ALTER TABLE `sqp_questionbulkassignments` ADD CONSTRAINT `country_id_refs_iso_64c7b67d` 
        FOREIGN KEY (`country_id`) REFERENCES `sqp_country` (`iso`);
        """)
        
        db.execute("""
        ALTER TABLE `sqp_questionbulkassignments` ADD CONSTRAINT `language_id_refs_id_7797b23c`
        FOREIGN KEY (`language_id`) REFERENCES `sqp_language` (`id`);
        """)
        
        db.execute("""
        ALTER TABLE `sqp_questionbulkassignments_users` ADD CONSTRAINT `questionbulkassignments_id_refs_id_32707ecc`
         FOREIGN KEY (`questionbulkassignments_id`) REFERENCES 
         `sqp_questionbulkassignments` (`id`);
        """)

        db.send_create_signal('sqp', ['QuestionBulkAssignments'])
        
        # Changing field 'UserProfile.user'
        db.alter_column('sqp_userprofile', 'user_id', self.gf('django.db.models.fields.related.OneToOneField')(unique=True, to=orm['auth.User']))

        # Adding unique constraint on 'UserProfile', fields ['user']
        db.create_unique('sqp_userprofile', ['user_id'])

    def forwards(self, orm):
        # replace domain view first
        db.execute_many(DB_VIEWS_FORWARDS)

        # Deleting field 'Domain.forward_canonical'
        db.delete_column('domain', 'forward_canonical')

        # Deleting field 'Domain.alias'
        db.delete_column('domain', 'alias_id')

        # Deleting field 'Domain.is_active'
        db.delete_column('domain', 'is_active')

def create_mviews():
    """Setups material views according to:
    http://tech.jonathangardner.net/wiki/PostgreSQL/Materialized_Views

    As a result the following functions are created:
        create_matview(name, name)
        drop_matview(name)
        refresh_matview(name)
        incremental_refresh_matview(name)
    and a table:
        matviews
    """
    mviews_sql = os.path.join(SQL_PATH, 'mviews.sql')
    db.execute_many(open(mviews_sql).read())

 def forwards(self, orm):
     #This had to be custom for the foreign key to iso to work with latin1 coalation
     sql = \
     """CREATE TABLE IF NOT EXISTS `sqp_codingchange` (
     `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
     `coding_change_group_id` integer NOT NULL,
     `question_id` integer NOT NULL,
     `characteristic_id` integer NOT NULL,
     `coding_user_id` integer,
     `change_by_id` integer,
     `change_type` integer NOT NULL,
     `new_value` varchar(15),
     `new_value_by_related_lang_id` integer,
     `new_value_by_related_country_id` varchar(2),
     `processed` bool NOT NULL,
     `error_occured` bool NOT NULL,
     `processing_log` longtext
     ) ENGINE = InnoDB DEFAULT CHARSET = latin1;
     
     ALTER TABLE `sqp_codingchange` ADD CONSTRAINT `coding_change_group_id_refs_id_66c2105b` 
     FOREIGN KEY (`coding_change_group_id`) REFERENCES `sqp_codingchangegroup` (`id`);
     
     ALTER TABLE `sqp_codingchange` ADD CONSTRAINT `characteristic_id_refs_id_6dbc9f64` 
     FOREIGN KEY (`characteristic_id`) REFERENCES `sqp_characteristic` (`id`);
 
     ALTER TABLE `sqp_codingchange` ADD CONSTRAINT 
     `new_value_by_related_country_id_refs_iso_41bf5fc6` 
     FOREIGN KEY (`new_value_by_related_country_id`) REFERENCES `sqp_country` (`iso`);
     
     ALTER TABLE `sqp_codingchange` ADD CONSTRAINT 
     `new_value_by_related_lang_id_refs_id_54b8e81` 
     FOREIGN KEY (`new_value_by_related_lang_id`) REFERENCES `sqp_language` (`id`);
     
     ALTER TABLE `sqp_codingchange` ADD CONSTRAINT 
     `coding_user_id_refs_id_6f519545` 
     FOREIGN KEY (`coding_user_id`) REFERENCES `auth_user` (`id`);
     
     ALTER TABLE `sqp_codingchange` ADD CONSTRAINT 
     `change_by_id_refs_id_6f519545` 
     FOREIGN KEY (`change_by_id`) REFERENCES `auth_user` (`id`);""" 
     
     db.execute_many(sql)
     db.send_create_signal('sqp', ['CodingChange'])

    def forwards(self, orm):
        
        # Adding field 'Course.number'
        db.add_column('courses_course', 'number', self.gf('django.db.models.fields.IntegerField')(default=0), keep_default=False)
        
        # Update values to match Course.id
        for course in orm.Course.objects.all():
            course.number = course.id
            course.save()

        # Make Course.number unique
        db.alter_column('courses_course', 'number', self.gf('django.db.models.fields.IntegerField')(unique=True))
        
        # Changing field 'Course.id'
        db.execute_many("""
            DROP SEQUENCE IF EXISTS courses_course_id_seq;
            CREATE SEQUENCE courses_course_id_seq OWNED BY courses_course.id;
            SELECT setval('courses_course_id_seq', (SELECT MAX(id) FROM courses_course));
            ALTER TABLE courses_course ALTER COLUMN id SET DEFAULT nextval('courses_course_id_seq');
        """)

 def forwards(self, orm):
     
     
     db.execute("""
         CREATE OR REPLACE VIEW hits_v AS 
          SELECT p.id AS status_id, q.id AS content_id, p.group_id, p.crawl_id, ( SELECT main_crawl.start_time
                    FROM main_crawl
                   WHERE main_crawl.id = p.crawl_id) AS start_time, q.requester_id, p.hits_available, p.page_number, p.inpage_position, p.hit_expiration_date, q.requester_name, q.reward, q.html, q.description, q.title, q.keywords, q.qualifications, q.time_alloted
            FROM main_hitgroupstatus p
            LEFT JOIN main_hitgroupcontent q ON p.group_id::text = q.group_id::text
           WHERE NOT (p.crawl_id IN ( SELECT DISTINCT hits_mv.crawl_id
               FROM hits_mv
              ORDER BY hits_mv.crawl_id));        
     """)
     
     db.execute_many("""
         CREATE OR REPLACE FUNCTION incremental_refresh_matview(name)
           RETURNS void AS
         '
          DECLARE 
              matview ALIAS FOR $1;
              entry matviews%ROWTYPE;
          BEGIN
         SELECT * INTO entry FROM matviews WHERE mv_name = matview;
         IF NOT FOUND THEN
                  RAISE EXCEPTION ''Materialized view % does not exist.'', matview;
             END IF;
         
             EXECUTE ''INSERT INTO '' || matview
                 || '' SELECT * FROM '' || entry.v_name;
         
             UPDATE matviews
                 SET last_refresh=CURRENT_TIMESTAMP
                 WHERE mv_name=matview;
         
             RETURN;
         END
         '
           LANGUAGE 'plpgsql' VOLATILE SECURITY DEFINER
           COST 100;        
     """)