Maybe it is a possibility to show the repeated calls. This way you can easily see that there are duplicated calls. (like they show in debug toolbar)

This is a very useful tool to debug django db performance.. but data can get cluttered between tons of small and meaningless requests. this allows the middleware user to selected the query elapsed time and the minimal query count that he wants the middleware to log. Enabling the user to focus on bottlenecks and problems.

Without explicitly changing the settings the current behavior isn't changed in any way

This PR adds functionality to return a custom response header with total request & response query count. We plan to use this functionality in our integration test suite, to ensure all endpoints are under the allowed count.

Additionally, when attempting to override the settings to ensure the header was being removed, I found the need to ensure the settings are reloaded, so I've cleaned up the settings application and wired them up to the Django setting changed signal.

Now django-querycount statistic all sql querys, this pr makes django-querycount can filter sql query by IGNORE_SQL_PATTERNS.

Fix simple typo in README

This adds support for Django 1.10-style middleware: https://docs.djangoproject.com/en/1.10/topics/http/middleware/#upgrading-pre-django-1-10-style-middleware

On Windows, using powershell, the output looks bad as colors are not supported :

http://127.0.0.1:8000/admin/jsi18n/
?[0m|------|-----------|----------|----------|----------|------------|
| Type | Database  |   Reads  |  Writes  |  Totals  | Duplicates |
|------|-----------|----------|----------|----------|------------|
?[32m| RESP |  default  |    2     |    0     |    2     |     1      |
?[0m|------|-----------|----------|----------|----------|------------|
?[32mTotal queries: 2 in 0.0160s

Colors should be disabled when not supported or disabled. I believe Django has all the logic needed in django\core\management\color.py

It prints this:

web_1            | Repeated 1 times.
web_1            | SELECT `django_session`.`session_key`,
web_1            | `django_session`.`session_data`, `django_session`.`expire_date` FROM
web_1            | `django_session` WHERE (`django_session`.`session_key` =
web_1            | 'cln2uzh2qk21qqb6sfg7nvsrqwg2crbm' AND `django_session`.`expire_date`
web_1            | > '2019-09-20 12:53:39.352699')

But I think it actually ever happens 1 time for that request. So, the logic for this inclusion should be something like [query for queries if query.times > 1].

Can we show the total time take for the repeated calls individually

For example: presently it shows Repeated 2 times.

Can we have Repeated 2 times. [0.023]

I wanted the sql to be formatted so i have tried the below code for that. Can you incorporate sqlparse also if possible

def _duplicate_queries(self, output):
        """Appends the most common duplicate queries to the given output."""
        if QC_SETTINGS['DISPLAY_DUPLICATES']:
            for query, count in self.queries.most_common(QC_SETTINGS['DISPLAY_DUPLICATES']):
                lines = '\nRepeated {0} times.'.format(count)
                #lines += wrap(query)
                #lines = "\n".join(lines) + "\n"
                lines += "\n" + self._str_query(query) + "\n"
                output += self._colorize(lines, count)
        return output

    def _str_query(self,sql):

        # Check if Pygments is available for coloring
        try:
            import pygments
            from pygments.lexers import SqlLexer
            from pygments.formatters import TerminalTrueColorFormatter
        except ImportError:
            pygments = None
        # Check if sqlparse is available for indentation
        try:
            import sqlparse
        except ImportError:
            sqlparse = None
        # Remove leading and trailing whitespaces
        if sqlparse:
            # Indent the SQL query
            sql = sqlparse.format(sql, reindent=True)
        if pygments:
            # Highlight the SQL query
            sql = pygments.highlight(
                sql,
                SqlLexer(),
                #TerminalTrueColorFormatter(style='monokai')
                TerminalTrueColorFormatter()
            )

        return sql

I often debug a single endpoint with a unique request pattern. To be able to only see that in the console I have to blacklist all other request patterns that my application may produce during debugging. That can be quite annoying. It would be helpful to have a separate whitelist setting like INCLUDE_REQUEST_PATTERNS where I just state what I want to be printed to the console and everything else is silenced. Of course the User would have to decide whether to blacklist or whitelist, as using both does not make much sense.

I can do a PR if you want, let me know if it's something worth putting time into.

This will many duplicates that only vary by <some_number>, indicating an N+1 condition.

Hey, is it possible to print SQL commands like here (screenshot from README)?

I have default settings and get only queries number and time without SQL

Hi, thanks for this awesome package. I really enjoy using it.

But I have a question about how to use this package without a request instance? Here are some examples where I need this:

1. celery tasks, in DEBUG I want them to print the query count in the same manner middleware does
2. telegram bots, we do develop some telegram bots on top of django. telegram bots serve as clients which does not have any django's request instance. But I still want this app to work

Thanks!