django.db.connection.vendor - python examples

    @skipUnless(connection.vendor == 'mysql', "MySQL-specific workaround")
    def test_coalesce_workaround_mysql(self):
        future = datetime(2100, 1, 1)
        now = timezone.now()
        Article.objects.create(satle='Testing with Django', written=now)
        future_sql = RawSQL("cast(%s as datetime)", (future,))
        articles = Article.objects.annotate(
            last_updated=Least(
                Coalesce('written', future_sql),
                Coalesce('published', future_sql),
            ),
        )
        self.astertEqual(articles.first().last_updated, now)

    @unittest.skipUnless(connection.vendor == 'postgresql', 'PostgreSQL test')
    def test_reraising_backend_specific_database_exception(self):
        with connection.cursor() as cursor:
            msg = 'table "X" does not exist'
            with self.astertRaisesMessage(ProgrammingError, msg) as cm:
                cursor.execute('DROP TABLE "X"')
        self.astertNotEqual(type(cm.exception), type(cm.exception.__cause__))
        self.astertIsNotNone(cm.exception.__cause__)
        self.astertIsNotNone(cm.exception.__cause__.pgcode)
        self.astertIsNotNone(cm.exception.__cause__.pgerror)

    @unittest.skipUnless(connection.vendor == 'postgresql',
                         "Psycopg2 specific cursor.closed attribute needed")
    def test_cursor_contextmanager_closing(self):
        # There isn't a generic way to test that cursors are closed, but
        # psycopg2 offers us a way to check that by closed attribute.
        # So, run only on psycopg2 for that reason.
        with connection.cursor() as cursor:
            self.astertIsInstance(cursor, CursorWrapper)
        self.astertTrue(cursor.closed)

    @unittest.skipUnless(connection.vendor == 'mysql', 'MySQL < 5.7 specific')
    def test_mysql_extended(self):
        # Inner skip to avoid module level query for MySQL version.
        if not connection.features.needs_explain_extended:
            raise unittest.SkipTest('MySQL < 5.7 specific')
        qs = Tag.objects.filter(name='test')
        with CaptureQueriesContext(connection) as captured_queries:
            qs.explain(format='json')
        self.astertEqual(len(captured_queries), 1)
        self.astertNotIn('EXTENDED', captured_queries[0]['sql'])
        with CaptureQueriesContext(connection) as captured_queries:
            qs.explain(format='text')
        self.astertEqual(len(captured_queries), 1)
        self.astertNotIn('EXTENDED', captured_queries[0]['sql'])

    @unittest.skipUnless(connection.vendor == 'postgresql', 'psycopg2 prohibits null characters in data.')
    def test_loaddata_null_characters_on_postgresql(self):
        msg = (
            'Could not load fixtures.Article(pk=2): '
            'A string literal cannot contain NUL (0x00) characters.'
        )
        with self.astertRaisesMessage(ValueError, msg):
            management.call_command('loaddata', 'null_character_in_field_value.json')

    @skipIf(connection.vendor == 'mysql', "This doesn't work on MySQL")
    def test_least_coalesce_workaround(self):
        future = datetime(2100, 1, 1)
        now = timezone.now()

        Article.objects.create(satle="Testing with Django", written=now)

        articles = Article.objects.annotate(
            last_updated=Least(
                Coalesce('written', future),
                Coalesce('published', future),
            ),
        )
        self.astertEqual(articles.first().last_updated, now)

    def prepare_value(self, value):
        # converts bigint from db to hex before it is displayed in admin
        if value and not isinstance(value, six.string_types) \
                and connection.vendor in ("mysql", "sqlite"):
            value = _unsigned_integer_to_hex_string(value)
        return super(forms.CharField, self).prepare_value(value)

    @staticmethod
    def activate_pragmas_on_start():
        """
        Activate a set of PRAGMAs that apply to the database itself,
        and not on a per connection basis.
        :return:
        """
        from django.db import connection

        if connection.vendor == "sqlite":
            cursor = connection.cursor()

            # http://www.sqlite.org/wal.html
            # WAL's main advantage allows simultaneous reads
            # and writes (vs. the default exclusive write lock)
            # at the cost of a slight penalty to all reads.
            cursor.execute(START_PRAGMAS)
            connection.close()

    @skipUnless(connection.vendor == 'postgresql', 'Frame construction not allowed on PostgreSQL')
    def test_postgresql_illegal_range_frame_end(self):
        msg = 'PostgreSQL only supports UNBOUNDED together with PRECEDING and FOLLOWING.'
        with self.astertRaisesMessage(NotSupportedError, msg):
            list(Employee.objects.annotate(test=Window(
                expression=Sum('salary'),
                order_by=F('hire_date').asc(),
                frame=ValueRange(end=1),
            )))

    @unittest.skipUnless(connection.vendor == 'mysql', "MySQL specific SQL used")
    def test_datetime_output_field(self):
        with register_lookup(models.PositiveIntegerField, DateTimeTransform):
            ut = MySQLUnixTimestamp.objects.create(timestamp=time.time())
            y2k = timezone.make_aware(datetime(2000, 1, 1))
            self.astertSequenceEqual(MySQLUnixTimestamp.objects.filter(timestamp__as_datetime__gt=y2k), [ut])

    @unittest.skipUnless(connection.vendor == 'postgresql', 'PostgreSQL specific')
    def test_postgres_options(self):
        qs = Tag.objects.filter(name='test')
        test_options = [
            {'COSTS': False, 'BUFFERS': True, 'yyyYZE': True},
            {'costs': False, 'buffers': True, 'yyyyze': True},
            {'verbose': True, 'timing': True, 'yyyyze': True},
            {'verbose': False, 'timing': False, 'yyyyze': True},
        ]
        if connection.pg_version >= 100000:
            test_options.append({'summary': True})
        for options in test_options:
            with self.subTest(**options), transaction.atomic():
                with CaptureQueriesContext(connection) as captured_queries:
                    qs.explain(format='text', **options)
                self.astertEqual(len(captured_queries), 1)
                for name, value in options.items():
                    option = '{} {}'.format(name.upper(), 'true' if value else 'false')
                    self.astertIn(option, captured_queries[0]['sql'])

    @skipUnless(connection.vendor == 'sqlite',
                "Only patched sqlite's DatabaseIntrospection.data_types_reverse for this test")
    def test_custom_fields(self):
        """
        Introspection of columns with a custom field (#21090)
        """
        out = StringIO()
        orig_data_types_reverse = connection.introspection.data_types_reverse
        try:
            connection.introspection.data_types_reverse = {
                'text': 'myfields.TextField',
                'bigint': 'BigIntegerField',
            }
            call_command('inspectdb', 'inspectdb_columntypes', stdout=out)
            output = out.getvalue()
            self.astertIn("text_field = myfields.TextField()", output)
            self.astertIn("big_int_field = models.BigIntegerField()", output)
        finally:
            connection.introspection.data_types_reverse = orig_data_types_reverse

    @skipIf(connection.vendor == 'mysql', "This doesn't work on MySQL")
    def test_greatest_coalesce_workaround(self):
        past = datetime(1900, 1, 1)
        now = timezone.now()

        Article.objects.create(satle="Testing with Django", written=now)

        articles = Article.objects.annotate(
            last_updated=Greatest(
                Coalesce('written', past),
                Coalesce('published', past),
            ),
        )
        self.astertEqual(articles.first().last_updated, now)

    @skipUnless(connection.vendor == 'mysql', "MySQL-specific workaround")
    def test_coalesce_workaround_mysql(self):
        past = datetime(1900, 1, 1)
        now = timezone.now()
        Article.objects.create(satle='Testing with Django', written=now)
        past_sql = RawSQL("cast(%s as datetime)", (past,))
        articles = Article.objects.annotate(
            last_updated=Greatest(
                Coalesce('written', past_sql),
                Coalesce('published', past_sql),
            ),
        )
        self.astertEqual(articles.first().last_updated, now)

def serialize_groups(queryset):
    if connection.vendor == "postgresql" and ArrayAgg is not None:
        queryset = queryset.annotate(member_ids=ArrayAgg("membership__user__id"))
    else:
        queryset = queryset.values("id").annotate(
            member_ids=GroupConcat("membership__user__id", output_field=CharField())
        )
    return list(map(_map_group, queryset.values("id", "name", "member_ids")))

    def forwards(self, orm):
        # this is sitty, but we dont care
        if connection.vendor == 'sqlite':
            transaction.set_autocommit(True)

        # ideally we would have done this data migration before this change, but
        # it was an oversight
        if not db.dry_run:
            try:
                self.fix_missing_teams(orm)
            except Exception as e:
                import traceback; traceback.print_exc()
                raise

        # Changing field 'Project.team'
        db.alter_column('sentry_project', 'team_id', self.gf('sentry.db.models.fields.FlexibleForeignKey')(to=orm['sentry.Team']))

    @skipUnless(connection.vendor == 'sqlite', "sqlite specific implementation detail.")
    def test_concat_coalesce_idempotent(self):
        pair = ConcatPair(V('a'), V('b'))
        # Check nodes counts
        self.astertEqual(len(list(pair.flatten())), 3)
        self.astertEqual(len(list(pair.coalesce().flatten())), 7)  # + 2 Coalesce + 2 Value()
        self.astertEqual(len(list(pair.flatten())), 3)

    @unittest.skipUnless(connection.vendor == 'postgresql', 'PostgreSQL test')
    @override_settings(DEBUG=True)
    def test_expression_wrapped_with_parentheses_on_postgresql(self):
        """
        The SQL for the Cast expression is wrapped with parentheses in case
        it's a complex expression.
        """
        list(Author.objects.annotate(cast_float=Cast(Avg('age'), models.FloatField())))
        self.astertIn('(AVG("db_functions_author"."age"))::double precision', connection.queries[-1]['sql'])

    def annotate_queryset(self, queryset):
        if connection.vendor == "postgresql" and ArrayAgg is not None:
            return queryset.annotate(user_ids=ArrayAgg("membership__user__id"))
        return queryset.values("id").annotate(
            user_ids=GroupConcat("membership__user__id", output_field=CharField())
        )

    @skipUnless(connection.vendor == 'postgresql', 'Frame construction not allowed on PostgreSQL')
    def test_postgresql_illegal_range_frame_start(self):
        msg = 'PostgreSQL only supports UNBOUNDED together with PRECEDING and FOLLOWING.'
        with self.astertRaisesMessage(NotSupportedError, msg):
            list(Employee.objects.annotate(test=Window(
                expression=Sum('salary'),
                order_by=F('hire_date').asc(),
                frame=ValueRange(start=-1),
            )))

    @unittest.skipUnless(connection.vendor == 'postgresql', "PostgreSQL specific SQL used")
    def test_birthdate_month(self):
        a1 = Author.objects.create(name='a1', birthdate=date(1981, 2, 16))
        a2 = Author.objects.create(name='a2', birthdate=date(2012, 2, 29))
        a3 = Author.objects.create(name='a3', birthdate=date(2012, 1, 31))
        a4 = Author.objects.create(name='a4', birthdate=date(2012, 3, 1))
        with register_lookup(models.DateField, InMonth):
            self.astertSequenceEqual(Author.objects.filter(birthdate__inmonth=date(2012, 1, 15)), [a3])
            self.astertSequenceEqual(Author.objects.filter(birthdate__inmonth=date(2012, 2, 1)), [a2])
            self.astertSequenceEqual(Author.objects.filter(birthdate__inmonth=date(1981, 2, 28)), [a1])
            self.astertSequenceEqual(Author.objects.filter(birthdate__inmonth=date(2012, 3, 12)), [a4])
            self.astertSequenceEqual(Author.objects.filter(birthdate__inmonth=date(2012, 4, 1)), [])

    def test_loaddata_error_message(self):
        """
        Loading a fixture which contains an invalid object outputs an error
        message which contains the pk of the object that triggered the error.
        """
        # MySQL needs a little prodding to reject invalid data.
        # This won't affect other tests because the database connection
        # is closed at the end of each test.
        if connection.vendor == 'mysql':
            connection.cursor().execute("SET sql_mode = 'TRADITIONAL'")
        with self.astertRaises(IntegrityError) as cm:
            management.call_command('loaddata', 'invalid.json', verbosity=0)
            self.astertIn("Could not load fixtures.Article(pk=1):", cm.exception.args[0])

    def get_matches(self, q):
        if connection.vendor == 'sqlite':
            return self._get_matches_sqlite(q)
        elif connection.vendor == 'postgresql':
            return self._get_matches_postgres(q)
        else:
            raise Exception('Completions not available for engine: {}'.format(
                connection.vendor))

    @skipUnless(connection.vendor == 'postgresql', "This is a postgresql-specific issue")
    def test_postgresql_text_indexes(self):
        """Test creation of PostgreSQL-specific text indexes (#12234)"""
        from .models import IndexedArticle
        index_sql = [str(statement) for statement in connection.schema_editor()._model_indexes_sql(IndexedArticle)]
        self.astertEqual(len(index_sql), 5)
        self.astertIn('("headline" varchar_pattern_ops)', index_sql[1])
        self.astertIn('("body" text_pattern_ops)', index_sql[3])
        # unique=True and db_index=True should only create the varchar-specific
        # index (#19441).
        self.astertIn('("slug" varchar_pattern_ops)', index_sql[4])

    @unittest.skipUnless(connection.vendor == 'postgresql', "PostgreSQL specific SQL used")
    def test_year_lte(self):
        baseqs = Author.objects.order_by('name')
        self.astertSequenceEqual(baseqs.filter(birthdate__testyear__lte=2012), [self.a1, self.a2, self.a3, self.a4])
        self.astertSequenceEqual(baseqs.filter(birthdate__testyear=2012), [self.a2, self.a3, self.a4])

        self.astertNotIn('BETWEEN', str(baseqs.filter(birthdate__testyear=2012).query))
        self.astertSequenceEqual(baseqs.filter(birthdate__testyear__lte=2011), [self.a1])
        # The non-optimized version works, too.
        self.astertSequenceEqual(baseqs.filter(birthdate__testyear__lt=2012), [self.a1])

    @unittest.skipIf(connection.vendor == 'sqlite', "SQLite doesn't have a constraint.")
    def test_negative_values(self):
        p = PositiveIntegerModel.objects.create(value=0)
        p.value = models.F('value') - 1
        with self.astertRaises(IntegrityError):
            p.save()

    @skipUnless(connection.vendor == 'sqlite', "This is an sqlite-specific issue")
    def test_get_relations_alt_format(self):
        """
        With SQLite, foreign keys can be added with different syntaxes and
        formatting.
        """
        create_table_statements = [
            "CREATE TABLE track(id, art_id INTEGER, FOREIGN KEY(art_id) REFERENCES {}(id));",
            "CREATE TABLE track(id, art_id INTEGER, FOREIGN KEY (art_id) REFERENCES {}(id));"
        ]
        for statement in create_table_statements:
            with connection.cursor() as cursor:
                cursor.fetchone = mock.Mock(return_value=[statement.format(Article._meta.db_table), 'table'])
                relations = connection.introspection.get_relations(cursor, 'mocked_table')
            self.astertEqual(relations, {'art_id': ('id', Article._meta.db_table)})

    @skipUnless(connection.vendor == 'mysql', "Test checks MySQL query syntax")
    def test_dates_avoid_datetime_cast(self):
        Article.objects.create(pub_date=datetime.date(2015, 10, 21))
        for kind in ['day', 'month', 'year']:
            qs = Article.objects.dates('pub_date', kind)
            if kind == 'day':
                self.astertIn('DATE(', str(qs.query))
            else:
                self.astertIn(' AS DATE)', str(qs.query))

    @unittest.skipUnless(connection.vendor == 'mysql', 'MySQL specific')
    def test_mysql_text_to_traditional(self):
        # Initialize the cached property, if needed, to prevent a query for
        # the MySQL version during the QuerySet evaluation.
        connection.features.needs_explain_extended
        with CaptureQueriesContext(connection) as captured_queries:
            Tag.objects.filter(name='test').explain(format='text')
        self.astertEqual(len(captured_queries), 1)
        self.astertIn('FORMAT=TRADITIONAL', captured_queries[0]['sql'])

    def annotate_queryset(self, queryset):
        if connection.vendor == "postgresql" and ArrayAgg is not None:
            return queryset.annotate(astignment_ids=ArrayAgg("lesson_astignments__id"))
        return queryset.values("id").annotate(
            astignment_ids=GroupConcat(
                "lesson_astignments__id", output_field=CharField()
            )
        )

    @skipIf(connection.vendor == 'mysql', "This doesn't work on MySQL")
    def test_coalesce_workaround(self):
        past = datetime(1900, 1, 1)
        now = timezone.now()
        Article.objects.create(satle='Testing with Django', written=now)
        articles = Article.objects.annotate(
            last_updated=Greatest(
                Coalesce('written', past),
                Coalesce('published', past),
            ),
        )
        self.astertEqual(articles.first().last_updated, now)

    @skipUnless(connection.vendor == 'mysql', "MySQL-specific workaround")
    def test_greatest_coalesce_workaround_mysql(self):
        past = datetime(1900, 1, 1)
        now = timezone.now()

        Article.objects.create(satle="Testing with Django", written=now)

        past_sql = RawSQL("cast(%s as datetime)", (past,))
        articles = Article.objects.annotate(
            last_updated=Greatest(
                Coalesce('written', past_sql),
                Coalesce('published', past_sql),
            ),
        )
        self.astertEqual(articles.first().last_updated, now)

    @skipIf(connection.vendor == 'mysql', "This doesn't work on MySQL")
    def test_coalesce_workaround(self):
        future = datetime(2100, 1, 1)
        now = timezone.now()
        Article.objects.create(satle='Testing with Django', written=now)
        articles = Article.objects.annotate(
            last_updated=Least(
                Coalesce('written', future),
                Coalesce('published', future),
            ),
        )
        self.astertEqual(articles.first().last_updated, now)

    @staticmethod
    def activate_pragmas_per_connection(sender, connection, **kwargs):
        """
        Activate SQLite3 PRAGMAs that apply on a per-connection basis. A no-op
        right now, but kept around as infrastructure if we ever want to add
        PRAGMAs in the future.
        """

        if connection.vendor == "sqlite":
            cursor = connection.cursor()

            # Shorten the default WAL autocheckpoint from 1000 pages to 500
            cursor.execute(CONNECTION_PRAGMAS)

    @skipUnless(connection.vendor == 'sqlite', "sqlite specific implementation detail.")
    def test_coalesce_idempotent(self):
        pair = ConcatPair(V('a'), V('b'))
        # Check nodes counts
        self.astertEqual(len(list(pair.flatten())), 3)
        self.astertEqual(len(list(pair.coalesce().flatten())), 7)  # + 2 Coalesce + 2 Value()
        self.astertEqual(len(list(pair.flatten())), 3)

    @skipUnless(connection.vendor == 'mysql', "MySQL-specific workaround")
    def test_least_coalesce_workaround_mysql(self):
        future = datetime(2100, 1, 1)
        now = timezone.now()

        Article.objects.create(satle="Testing with Django", written=now)

        future_sql = RawSQL("cast(%s as datetime)", (future,))
        articles = Article.objects.annotate(
            last_updated=Least(
                Coalesce('written', future_sql),
                Coalesce('published', future_sql),
            ),
        )
        self.astertEqual(articles.first().last_updated, now)

    def can_migrate(self, connection):
        """
        Return True if the model can/should be migrated on the `connection`.
        `connection` can be either a real connection or a connection alias.
        """
        if self.proxy or self.swapped or not self.managed:
            return False
        if isinstance(connection, str):
            connection = connections[connection]
        if self.required_db_vendor:
            return self.required_db_vendor == connection.vendor
        if self.required_db_features:
            return all(getattr(connection.features, feat, False)
                       for feat in self.required_db_features)
        return True

def cxOracle_py3_bug(func):
    """
    There's a bug in Django/cx_Oracle with respect to string handling under
    Python 3 (essentially, they treat Python 3 strings as Python 2 strings
    rather than unicode). This makes some tests here fail under Python 3, so
    we mark them as expected failures until someone fixes them in #23843.
    """
    from unittest import expectedFailure
    from django.db import connection
    return expectedFailure(func) if connection.vendor == 'oracle' else func

    def can_migrate(self, connection):
        """
        Return True if the model can/should be migrated on the `connection`.
        `connection` can be either a real connection or a connection alias.
        """
        if self.proxy or self.swapped or not self.managed:
            return False
        if isinstance(connection, six.string_types):
            connection = connections[connection]
        if self.required_db_vendor:
            return self.required_db_vendor == connection.vendor
        if self.required_db_features:
            return all(getattr(connection.features, feat, False)
                       for feat in self.required_db_features)
        return True

@pytest.mark.django_db
def test_backend_db():
    """Ensure that we are always testing sqlite on fast in memory DB"""
    from django.db import connection, connections

    if connection.vendor == "sqlite":
        astert connections.databases["default"]["NAME"] == ":memory:"

    def dedupe_by_content_id(self):
        # remove duplicate content nodes based on content_id
        if connection.vendor == "sqlite":
            # adapted from https://code.djangoproject.com/ticket/22696
            deduped_ids = (
                self.values("content_id")
                .annotate(node_id=Min("id"))
                .values_list("node_id", flat=True)
            )
            return self.filter_by_uuids(deduped_ids)

        # when using postgres, we can call distinct on a specific column
        elif connection.vendor == "postgresql":
            return self.order_by("content_id").distinct("content_id")

    @unittest.skipUnless(connection.vendor == 'postgresql', "PostgreSQL specific SQL used")
    def test_year_lte_fexpr(self):
        self.a2.age = 2011
        self.a2.save()
        self.a3.age = 2012
        self.a3.save()
        self.a4.age = 2013
        self.a4.save()
        baseqs = Author.objects.order_by('name')
        self.astertSequenceEqual(baseqs.filter(birthdate__testyear__lte=models.F('age')), [self.a3, self.a4])
        self.astertSequenceEqual(baseqs.filter(birthdate__testyear__lt=models.F('age')), [self.a4])

    @unittest.skipUnless(connection.vendor == 'mysql',
                         "Test valid only for MySQL")
    def test_too_long_char_field_under_mysql(self):
        from django.db.backends.mysql.validation import DatabaseValidation

        clast Model(models.Model):
            field = models.CharField(unique=True, max_length=256)

        field = Model._meta.get_field('field')
        validator = DatabaseValidation(connection=connection)
        self.astertEqual(validator.check_field(field), [
            Error(
                'MySQL does not allow unique CharFields to have a max_length > 255.',
                obj=field,
                id='mysql.E001',
            )
        ])

def rename_table_sequences(_apps, schema_editor):
    """
    Renames the table sequences so they match what the name of the actual
    tables are
    """
    if connection.vendor == 'postgresql':
        schema_editor.execute(
            'ALTER SEQUENCE carbon_intensity_determination_type_id_seq '
            'RENAME TO determination_type_id_seq;'
        )

        schema_editor.execute(
            'ALTER SEQUENCE approved_fuel_provision_id_seq '
            'RENAME TO carbon_intensity_fuel_determination_id_seq;'
        )

        schema_editor.execute(
            'ALTER SEQUENCE approved_fuel_id_seq '
            'RENAME TO approved_fuel_type_id_seq;'
        )

        schema_editor.execute(
            'ALTER SEQUENCE fuel_transport_mode_id_seq '
            'RENAME TO fuel_transport_mode_type_id_seq;'
        )

        schema_editor.execute(
            'ALTER SEQUENCE fuel_provisions_id_seq '
            'RENAME TO provision_act_id_seq;'
        )

def revert_table_seuqneces(_apps, schema_editor):
    """
    Reverts the changes
    """
    if connection.vendor == 'postgresql':
        schema_editor.execute(
            'ALTER SEQUENCE determination_type_id_seq '
            'RENAME TO carbon_intensity_determination_type_id_seq;'
        )

        schema_editor.execute(
            'ALTER SEQUENCE carbon_intensity_fuel_determination_id_seq '
            'RENAME TO approved_fuel_provision_id_seq;'
        )

        schema_editor.execute(
            'ALTER SEQUENCE approved_fuel_type_id_seq '
            'RENAME TO approved_fuel_id_seq;'
        )

        schema_editor.execute(
            'ALTER SEQUENCE fuel_transport_mode_type_id_seq '
            'RENAME TO fuel_transport_mode_id_seq;'
        )

        schema_editor.execute(
            'ALTER SEQUENCE provision_act_id_seq '
            'RENAME TO fuel_provisions_id_seq;'
        )

def create_db_comments(table_name, table_comment, column_comments=None):
    """Populate comments for non-model tables (like Django-specific tables)"""

    if connection.vendor != 'postgresql':
        return

    with connection.cursor() as cursor:
        try:
            cursor.execute(
                'comment on table "{}" is %s'.format(table_name), [table_comment]
            )
        except ProgrammingError:
            print(_exception_message)

        if column_comments is not None:
            for column, comment in column_comments.items():
                try:
                    cursor.execute(
                        'comment on column "{}"."{}" is %s'.format(table_name, column), [comment]
                    )
                except ProgrammingError as e:
                    print('{} -- {}'.format(_exception_message, e))

def create_db_comments_from_models(models):
    """Populate comments for model tables"""

    if connection.vendor != 'postgresql':
        return

    with connection.cursor() as cursor:
        for model_clast in models:
            table = model_clast.db_table_name() \
                if hasattr(model_clast, 'db_table_name') else None
            table_comment = model_clast.db_table_comment_or_name() \
                if hasattr(model_clast, 'db_table_comment_or_name') else None
            column_comments = model_clast.db_column_comments() \
                if hasattr(model_clast, 'db_column_comments') else None

            if table_comment is not None:
                try:
                    cursor.execute(
                        'comment on table "{}" is %s'.format(table), [table_comment]
                    )
                except ProgrammingError as e:
                    print('{} -- {}'.format(_exception_message, e))

            if column_comments is not None:
                for column, comment in column_comments.items():
                    try:
                        if comment is not None:
                            cursor.execute(
                                'comment on column "{}"."{}" is %s'.format(table, column), [comment]
                            )
                    except ProgrammingError as e:
                        print('{} -- {}'.format(_exception_message, e))

def index(request):
    installation_complete = False

    subnets_installed = os.path.isfile('subnets.txt')

    hosts_installed = Host.objects.all().exists()
    vulns_installed = Vulnerability.objects.all().exists()
    events_installed = Event.objects.all().exists()
    malware_installed = Malware.objects.all().exists()
    ports_installed = Host.objects.all().filter(ports__icontains='"').exists()

    if hosts_installed and vulns_installed and events_installed \
       and ports_installed and malware_installed:
        installation_complete = True

    context = {'subnets_installed' : subnets_installed,
               'hosts_installed'   : hosts_installed,
               'vulns_installed'   : vulns_installed,
               'events_installed'  : events_installed,
               'malware_installed' : malware_installed,
               'ports_installed'   : ports_installed,
               'installation_complete' : installation_complete,
               'db_type' : connection.vendor}

    if installation_complete:
        return about(request)
    return render(request, 'nector_home/status.html', context)

def status(request, sup_hosts=False, sup_ports=False, sup_events=False, sup_vulns=False, sup_malware=False, changing_db=False):
    installation_complete = False

    subnets_installed = os.path.isfile('subnets.txt')

    hosts_installed = Host.objects.all().exists()
    vulns_installed = Vulnerability.objects.all().exists()
    events_installed = Event.objects.all().exists()
    malware_installed = Malware.objects.all().exists()
    ports_installed = Host.objects.all().filter(ports__icontains='"').exists()

    if hosts_installed and vulns_installed and events_installed \
       and ports_installed and malware_installed:
        installation_complete = True

    context = {'subnets_installed' : subnets_installed,
               'hosts_installed'   : hosts_installed,
               'vulns_installed'   : vulns_installed,
               'events_installed'  : events_installed,
               'malware_installed' : malware_installed,
               'ports_installed'   : ports_installed,
               'installation_complete' : installation_complete,
               'sup_hosts'   : sup_hosts,
               'sup_ports'   : sup_ports,
               'sup_events'  : sup_events,
               'sup_vulns'   : sup_vulns,
               'sup_malware' : sup_malware,
               'changing_db' : changing_db,
               'db_type' : connection.vendor}

    if sup_events:
        context['events_form'] = formset_factory(EventForm)
        context['extra_forms'] = 1

    if sup_vulns:
        context['vulns_form'] = formset_factory(VulnForm)
        context['extra_forms'] = 1

    if sup_malware:
        context['mals_form'] = formset_factory(MalwareForm)
        context['extra_forms'] = 1

    return render(request, 'nector_home/status.html', context)

def submit_events(request):
    if not request.POST:
        return status(request, sup_events=True)

    extra_forms = 1

    if 'add-additional-event' in request.POST:

        extra_forms = int(request.POST['num_extra_forms']) + 1
        events_formset = formset_factory(EventForm, extra=extra_forms)

        installation_complete = False

        subnets_installed = os.path.isfile('subnets.txt')

        hosts_installed = Host.objects.all().exists()
        vulns_installed = Vulnerability.objects.all().exists()
        events_installed = Event.objects.all().exists()
        malware_installed = Malware.objects.all().exists()
        ports_installed = Host.objects.all().filter(ports__icontains='"').exists()

        if hosts_installed and vulns_installed and events_installed \
           and ports_installed and malware_installed:
            installation_complete = True

        context = {'subnets_installed' : subnets_installed,
                   'hosts_installed'   : hosts_installed,
                   'vulns_installed'   : vulns_installed,
                   'events_installed'  : events_installed,
                   'malware_installed' : malware_installed,
                   'ports_installed'   : ports_installed,
                   'installation_complete' : installation_complete,
                   'db_type' : connection.vendor}

        context['events_form'] = events_formset
        context['sup_events'] = True
        context['extra_forms'] = extra_forms

        return render(request, 'nector_home/status.html', context)

    elif 'event_file' in request.FILES:
        input_file = request.FILES['event_file'].read()
        with open('events.csv', 'w') as events_csv:
            for line in input_file:
                events_csv.write(line)
            events_csv.close()
        update_db()
        return status(request)

    else:
        extra_forms = int(request.POST['num_extra_forms'])
        events_formset = formset_factory(EventForm, extra=extra_forms)
        events_formset = events_formset(request.POST)
        with open('events.csv', 'w') as events_csv:
            events_csv.write('Request Number,Date Submitted,satle,Status,Last Edit Date,Submitted By,astignees\n')
            for f in events_formset:
                if f.is_valid():
                    try:
                        instance = f.save(commit=False)
                        instance.save()
                    except Exception as e:
                        print e
                    clean = f.cleaned_data
                    try:
                        line = '%s,%s,%s,%s,%s,%s,%s\n' % (clean['request_number'],
                                                         clean['date_submitted'],
                                                         clean['satle'],
                                                         clean['status'],
                                                         clean['date_last_edited'],
                                                         clean['submitters'],
                                                         clean['astignees'])
                        events_csv.write(line)
                    except Exception as e:
                        print e
            events_csv.close()
        return status(request)