17.12

venv/lib/python3.7/site-packages/django/db/backends/base/client.py

@@ -0,0 +1,12 @@
+class BaseDatabaseClient:
+    """Encapsulate backend-specific methods for opening a client shell."""
+    # This should be a string representing the name of the executable
+    # (e.g., "psql"). Subclasses must override this.
+    executable_name = None
+
+    def __init__(self, connection):
+        # connection is an instance of BaseDatabaseWrapper.
+        self.connection = connection
+
+    def runshell(self):
+        raise NotImplementedError('subclasses of BaseDatabaseClient must provide a runshell() method')

venv/lib/python3.7/site-packages/django/db/backends/base/features.py

@@ -0,0 +1,308 @@
+from django.db.utils import ProgrammingError
+from django.utils.functional import cached_property
+
+
+class BaseDatabaseFeatures:
+    gis_enabled = False
+    allows_group_by_pk = False
+    allows_group_by_selected_pks = False
+    empty_fetchmany_value = []
+    update_can_self_select = True
+
+    # Does the backend distinguish between '' and None?
+    interprets_empty_strings_as_nulls = False
+
+    # Does the backend allow inserting duplicate NULL rows in a nullable
+    # unique field? All core backends implement this correctly, but other
+    # databases such as SQL Server do not.
+    supports_nullable_unique_constraints = True
+
+    # Does the backend allow inserting duplicate rows when a unique_together
+    # constraint exists and some fields are nullable but not all of them?
+    supports_partially_nullable_unique_constraints = True
+
+    can_use_chunked_reads = True
+    can_return_id_from_insert = False
+    can_return_ids_from_bulk_insert = False
+    has_bulk_insert = True
+    uses_savepoints = True
+    can_release_savepoints = False
+
+    # If True, don't use integer foreign keys referring to, e.g., positive
+    # integer primary keys.
+    related_fields_match_type = False
+    allow_sliced_subqueries_with_in = True
+    has_select_for_update = False
+    has_select_for_update_nowait = False
+    has_select_for_update_skip_locked = False
+    has_select_for_update_of = False
+    # Does the database's SELECT FOR UPDATE OF syntax require a column rather
+    # than a table?
+    select_for_update_of_column = False
+
+    # Does the default test database allow multiple connections?
+    # Usually an indication that the test database is in-memory
+    test_db_allows_multiple_connections = True
+
+    # Can an object be saved without an explicit primary key?
+    supports_unspecified_pk = False
+
+    # Can a fixture contain forward references? i.e., are
+    # FK constraints checked at the end of transaction, or
+    # at the end of each save operation?
+    supports_forward_references = True
+
+    # Does the backend truncate names properly when they are too long?
+    truncates_names = False
+
+    # Is there a REAL datatype in addition to floats/doubles?
+    has_real_datatype = False
+    supports_subqueries_in_group_by = True
+
+    # Is there a true datatype for uuid?
+    has_native_uuid_field = False
+
+    # Is there a true datatype for timedeltas?
+    has_native_duration_field = False
+
+    # Does the database driver supports same type temporal data subtraction
+    # by returning the type used to store duration field?
+    supports_temporal_subtraction = False
+
+    # Does the __regex lookup support backreferencing and grouping?
+    supports_regex_backreferencing = True
+
+    # Can date/datetime lookups be performed using a string?
+    supports_date_lookup_using_string = True
+
+    # Can datetimes with timezones be used?
+    supports_timezones = True
+
+    # Does the database have a copy of the zoneinfo database?
+    has_zoneinfo_database = True
+
+    # When performing a GROUP BY, is an ORDER BY NULL required
+    # to remove any ordering?
+    requires_explicit_null_ordering_when_grouping = False
+
+    # Does the backend order NULL values as largest or smallest?
+    nulls_order_largest = False
+
+    # The database's limit on the number of query parameters.
+    max_query_params = None
+
+    # Can an object have an autoincrement primary key of 0? MySQL says No.
+    allows_auto_pk_0 = True
+
+    # Do we need to NULL a ForeignKey out, or can the constraint check be
+    # deferred
+    can_defer_constraint_checks = False
+
+    # date_interval_sql can properly handle mixed Date/DateTime fields and timedeltas
+    supports_mixed_date_datetime_comparisons = True
+
+    # Does the backend support tablespaces? Default to False because it isn't
+    # in the SQL standard.
+    supports_tablespaces = False
+
+    # Does the backend reset sequences between tests?
+    supports_sequence_reset = True
+
+    # Can the backend introspect the default value of a column?
+    can_introspect_default = True
+
+    # Confirm support for introspected foreign keys
+    # Every database can do this reliably, except MySQL,
+    # which can't do it for MyISAM tables
+    can_introspect_foreign_keys = True
+
+    # Can the backend introspect an AutoField, instead of an IntegerField?
+    can_introspect_autofield = False
+
+    # Can the backend introspect a BigIntegerField, instead of an IntegerField?
+    can_introspect_big_integer_field = True
+
+    # Can the backend introspect an BinaryField, instead of an TextField?
+    can_introspect_binary_field = True
+
+    # Can the backend introspect an DecimalField, instead of an FloatField?
+    can_introspect_decimal_field = True
+
+    # Can the backend introspect a DurationField, instead of a BigIntegerField?
+    can_introspect_duration_field = True
+
+    # Can the backend introspect an IPAddressField, instead of an CharField?
+    can_introspect_ip_address_field = False
+
+    # Can the backend introspect a PositiveIntegerField, instead of an IntegerField?
+    can_introspect_positive_integer_field = False
+
+    # Can the backend introspect a SmallIntegerField, instead of an IntegerField?
+    can_introspect_small_integer_field = False
+
+    # Can the backend introspect a TimeField, instead of a DateTimeField?
+    can_introspect_time_field = True
+
+    # Some backends may not be able to differentiate BigAutoField from other
+    # fields such as AutoField.
+    introspected_big_auto_field_type = 'BigAutoField'
+
+    # Some backends may not be able to differentiate BooleanField from other
+    # fields such as IntegerField.
+    introspected_boolean_field_type = 'BooleanField'
+
+    # Can the backend introspect the column order (ASC/DESC) for indexes?
+    supports_index_column_ordering = True
+
+    # Does the backend support introspection of materialized views?
+    can_introspect_materialized_views = False
+
+    # Support for the DISTINCT ON clause
+    can_distinct_on_fields = False
+
+    # Does the backend decide to commit before SAVEPOINT statements
+    # when autocommit is disabled? https://bugs.python.org/issue8145#msg109965
+    autocommits_when_autocommit_is_off = False
+
+    # Does the backend prevent running SQL queries in broken transactions?
+    atomic_transactions = True
+
+    # Can we roll back DDL in a transaction?
+    can_rollback_ddl = False
+
+    # Does it support operations requiring references rename in a transaction?
+    supports_atomic_references_rename = True
+
+    # Can we issue more than one ALTER COLUMN clause in an ALTER TABLE?
+    supports_combined_alters = False
+
+    # Does it support foreign keys?
+    supports_foreign_keys = True
+
+    # Does it support CHECK constraints?
+    supports_column_check_constraints = True
+    supports_table_check_constraints = True
+
+    # Does the backend support 'pyformat' style ("... %(name)s ...", {'name': value})
+    # parameter passing? Note this can be provided by the backend even if not
+    # supported by the Python driver
+    supports_paramstyle_pyformat = True
+
+    # Does the backend require literal defaults, rather than parameterized ones?
+    requires_literal_defaults = False
+
+    # Does the backend require a connection reset after each material schema change?
+    connection_persists_old_columns = False
+
+    # What kind of error does the backend throw when accessing closed cursor?
+    closed_cursor_error_class = ProgrammingError
+
+    # Does 'a' LIKE 'A' match?
+    has_case_insensitive_like = True
+
+    # Suffix for backends that don't support "SELECT xxx;" queries.
+    bare_select_suffix = ''
+
+    # If NULL is implied on columns without needing to be explicitly specified
+    implied_column_null = False
+
+    # Does the backend support "select for update" queries with limit (and offset)?
+    supports_select_for_update_with_limit = True
+
+    # Does the backend ignore null expressions in GREATEST and LEAST queries unless
+    # every expression is null?
+    greatest_least_ignores_nulls = False
+
+    # Can the backend clone databases for parallel test execution?
+    # Defaults to False to allow third-party backends to opt-in.
+    can_clone_databases = False
+
+    # Does the backend consider table names with different casing to
+    # be equal?
+    ignores_table_name_case = False
+
+    # Place FOR UPDATE right after FROM clause. Used on MSSQL.
+    for_update_after_from = False
+
+    # Combinatorial flags
+    supports_select_union = True
+    supports_select_intersection = True
+    supports_select_difference = True
+    supports_slicing_ordering_in_compound = False
+    supports_parentheses_in_compound = True
+
+    # Does the database support SQL 2003 FILTER (WHERE ...) in aggregate
+    # expressions?
+    supports_aggregate_filter_clause = False
+
+    # Does the backend support indexing a TextField?
+    supports_index_on_text_field = True
+
+    # Does the backend support window expressions (expression OVER (...))?
+    supports_over_clause = False
+
+    # Does the backend support CAST with precision?
+    supports_cast_with_precision = True
+
+    # How many second decimals does the database return when casting a value to
+    # a type with time?
+    time_cast_precision = 6
+
+    # SQL to create a procedure for use by the Django test suite. The
+    # functionality of the procedure isn't important.
+    create_test_procedure_without_params_sql = None
+    create_test_procedure_with_int_param_sql = None
+
+    # Does the backend support keyword parameters for cursor.callproc()?
+    supports_callproc_kwargs = False
+
+    # Convert CharField results from bytes to str in database functions.
+    db_functions_convert_bytes_to_str = False
+
+    # What formats does the backend EXPLAIN syntax support?
+    supported_explain_formats = set()
+
+    # Does DatabaseOperations.explain_query_prefix() raise ValueError if
+    # unknown kwargs are passed to QuerySet.explain()?
+    validates_explain_options = True
+
+    # Does the backend support the default parameter in lead() and lag()?
+    supports_default_in_lead_lag = True
+
+    # Does the backend support ignoring constraint or uniqueness errors during
+    # INSERT?
+    supports_ignore_conflicts = True
+
+    # Does this backend require casting the results of CASE expressions used
+    # in UPDATE statements to ensure the expression has the correct type?
+    requires_casted_case_in_updates = False
+
+    # Does the backend support partial indexes (CREATE INDEX ... WHERE ...)?
+    supports_partial_indexes = True
+    supports_functions_in_partial_indexes = True
+
+    # Does the database allow more than one constraint or index on the same
+    # field(s)?
+    allows_multiple_constraints_on_same_fields = True
+
+    def __init__(self, connection):
+        self.connection = connection
+
+    @cached_property
+    def supports_explaining_query_execution(self):
+        """Does this backend support explaining query execution?"""
+        return self.connection.ops.explain_prefix is not None
+
+    @cached_property
+    def supports_transactions(self):
+        """Confirm support for transactions."""
+        with self.connection.cursor() as cursor:
+            cursor.execute('CREATE TABLE ROLLBACK_TEST (X INT)')
+            self.connection.set_autocommit(False)
+            cursor.execute('INSERT INTO ROLLBACK_TEST (X) VALUES (8)')
+            self.connection.rollback()
+            self.connection.set_autocommit(True)
+            cursor.execute('SELECT COUNT(X) FROM ROLLBACK_TEST')
+            count, = cursor.fetchone()
+            cursor.execute('DROP TABLE ROLLBACK_TEST')
+        return count == 0

venv/lib/python3.7/site-packages/django/db/backends/base/validation.py

@@ -0,0 +1,25 @@
+class BaseDatabaseValidation:
+    """Encapsulate backend-specific validation."""
+    def __init__(self, connection):
+        self.connection = connection
+
+    def check(self, **kwargs):
+        return []
+
+    def check_field(self, field, **kwargs):
+        errors = []
+        # Backends may implement a check_field_type() method.
+        if (hasattr(self, 'check_field_type') and
+                # Ignore any related fields.
+                not getattr(field, 'remote_field', None)):
+            # Ignore fields with unsupported features.
+            db_supports_all_required_features = all(
+                getattr(self.connection.features, feature, False)
+                for feature in field.model._meta.required_db_features
+            )
+            if db_supports_all_required_features:
+                field_type = field.db_type(self.connection)
+                # Ignore non-concrete fields.
+                if field_type is not None:
+                    errors.extend(self.check_field_type(field, field_type))
+        return errors

venv/lib/python3.7/site-packages/django/db/backends/mysql/client.py

@@ -0,0 +1,48 @@
+import subprocess
+
+from django.db.backends.base.client import BaseDatabaseClient
+
+
+class DatabaseClient(BaseDatabaseClient):
+    executable_name = 'mysql'
+
+    @classmethod
+    def settings_to_cmd_args(cls, settings_dict):
+        args = [cls.executable_name]
+        db = settings_dict['OPTIONS'].get('db', settings_dict['NAME'])
+        user = settings_dict['OPTIONS'].get('user', settings_dict['USER'])
+        passwd = settings_dict['OPTIONS'].get('passwd', settings_dict['PASSWORD'])
+        host = settings_dict['OPTIONS'].get('host', settings_dict['HOST'])
+        port = settings_dict['OPTIONS'].get('port', settings_dict['PORT'])
+        server_ca = settings_dict['OPTIONS'].get('ssl', {}).get('ca')
+        client_cert = settings_dict['OPTIONS'].get('ssl', {}).get('cert')
+        client_key = settings_dict['OPTIONS'].get('ssl', {}).get('key')
+        defaults_file = settings_dict['OPTIONS'].get('read_default_file')
+        # Seems to be no good way to set sql_mode with CLI.
+
+        if defaults_file:
+            args += ["--defaults-file=%s" % defaults_file]
+        if user:
+            args += ["--user=%s" % user]
+        if passwd:
+            args += ["--password=%s" % passwd]
+        if host:
+            if '/' in host:
+                args += ["--socket=%s" % host]
+            else:
+                args += ["--host=%s" % host]
+        if port:
+            args += ["--port=%s" % port]
+        if server_ca:
+            args += ["--ssl-ca=%s" % server_ca]
+        if client_cert:
+            args += ["--ssl-cert=%s" % client_cert]
+        if client_key:
+            args += ["--ssl-key=%s" % client_key]
+        if db:
+            args += [db]
+        return args
+
+    def runshell(self):
+        args = DatabaseClient.settings_to_cmd_args(self.connection.settings_dict)
+        subprocess.check_call(args)

venv/lib/python3.7/site-packages/django/db/backends/mysql/creation.py

@@ -0,0 +1,67 @@
+import subprocess
+import sys
+
+from django.db.backends.base.creation import BaseDatabaseCreation
+
+from .client import DatabaseClient
+
+
+class DatabaseCreation(BaseDatabaseCreation):
+
+    def sql_table_creation_suffix(self):
+        suffix = []
+        test_settings = self.connection.settings_dict['TEST']
+        if test_settings['CHARSET']:
+            suffix.append('CHARACTER SET %s' % test_settings['CHARSET'])
+        if test_settings['COLLATION']:
+            suffix.append('COLLATE %s' % test_settings['COLLATION'])
+        return ' '.join(suffix)
+
+    def _execute_create_test_db(self, cursor, parameters, keepdb=False):
+        try:
+            super()._execute_create_test_db(cursor, parameters, keepdb)
+        except Exception as e:
+            if len(e.args) < 1 or e.args[0] != 1007:
+                # All errors except "database exists" (1007) cancel tests.
+                self.log('Got an error creating the test database: %s' % e)
+                sys.exit(2)
+            else:
+                raise e
+
+    def _clone_test_db(self, suffix, verbosity, keepdb=False):
+        source_database_name = self.connection.settings_dict['NAME']
+        target_database_name = self.get_test_db_clone_settings(suffix)['NAME']
+        test_db_params = {
+            'dbname': self.connection.ops.quote_name(target_database_name),
+            'suffix': self.sql_table_creation_suffix(),
+        }
+        with self._nodb_connection.cursor() as cursor:
+            try:
+                self._execute_create_test_db(cursor, test_db_params, keepdb)
+            except Exception:
+                if keepdb:
+                    # If the database should be kept, skip everything else.
+                    return
+                try:
+                    if verbosity >= 1:
+                        self.log('Destroying old test database for alias %s...' % (
+                            self._get_database_display_str(verbosity, target_database_name),
+                        ))
+                    cursor.execute('DROP DATABASE %(dbname)s' % test_db_params)
+                    self._execute_create_test_db(cursor, test_db_params, keepdb)
+                except Exception as e:
+                    self.log('Got an error recreating the test database: %s' % e)
+                    sys.exit(2)
+        self._clone_db(source_database_name, target_database_name)
+
+    def _clone_db(self, source_database_name, target_database_name):
+        dump_args = DatabaseClient.settings_to_cmd_args(self.connection.settings_dict)[1:]
+        dump_args[-1] = source_database_name
+        dump_cmd = ['mysqldump', '--routines', '--events'] + dump_args
+        load_cmd = DatabaseClient.settings_to_cmd_args(self.connection.settings_dict)
+        load_cmd[-1] = target_database_name
+
+        with subprocess.Popen(dump_cmd, stdout=subprocess.PIPE) as dump_proc:
+            with subprocess.Popen(load_cmd, stdin=dump_proc.stdout, stdout=subprocess.DEVNULL):
+                # Allow dump_proc to receive a SIGPIPE if the load process exits.
+                dump_proc.stdout.close()

venv/lib/python3.7/site-packages/django/db/backends/mysql/features.py

@@ -0,0 +1,120 @@
+import operator
+
+from django.db.backends.base.features import BaseDatabaseFeatures
+from django.utils.functional import cached_property
+
+
+class DatabaseFeatures(BaseDatabaseFeatures):
+    empty_fetchmany_value = ()
+    update_can_self_select = False
+    allows_group_by_pk = True
+    related_fields_match_type = True
+    # MySQL doesn't support sliced subqueries with IN/ALL/ANY/SOME.
+    allow_sliced_subqueries_with_in = False
+    has_select_for_update = True
+    supports_forward_references = False
+    supports_regex_backreferencing = False
+    supports_date_lookup_using_string = False
+    can_introspect_autofield = True
+    can_introspect_binary_field = False
+    can_introspect_duration_field = False
+    can_introspect_small_integer_field = True
+    can_introspect_positive_integer_field = True
+    introspected_boolean_field_type = 'IntegerField'
+    supports_index_column_ordering = False
+    supports_timezones = False
+    requires_explicit_null_ordering_when_grouping = True
+    allows_auto_pk_0 = False
+    can_release_savepoints = True
+    atomic_transactions = False
+    supports_column_check_constraints = False
+    supports_table_check_constraints = False
+    can_clone_databases = True
+    supports_temporal_subtraction = True
+    supports_select_intersection = False
+    supports_select_difference = False
+    supports_slicing_ordering_in_compound = True
+    supports_index_on_text_field = False
+    has_case_insensitive_like = False
+    create_test_procedure_without_params_sql = """
+        CREATE PROCEDURE test_procedure ()
+        BEGIN
+            DECLARE V_I INTEGER;
+            SET V_I = 1;
+        END;
+    """
+    create_test_procedure_with_int_param_sql = """
+        CREATE PROCEDURE test_procedure (P_I INTEGER)
+        BEGIN
+            DECLARE V_I INTEGER;
+            SET V_I = P_I;
+        END;
+    """
+    db_functions_convert_bytes_to_str = True
+    # Alias MySQL's TRADITIONAL to TEXT for consistency with other backends.
+    supported_explain_formats = {'JSON', 'TEXT', 'TRADITIONAL'}
+    # Neither MySQL nor MariaDB support partial indexes.
+    supports_partial_indexes = False
+
+    @cached_property
+    def _mysql_storage_engine(self):
+        "Internal method used in Django tests. Don't rely on this from your code"
+        with self.connection.cursor() as cursor:
+            cursor.execute("SELECT ENGINE FROM INFORMATION_SCHEMA.ENGINES WHERE SUPPORT = 'DEFAULT'")
+            result = cursor.fetchone()
+        return result[0]
+
+    @cached_property
+    def can_introspect_foreign_keys(self):
+        "Confirm support for introspected foreign keys"
+        return self._mysql_storage_engine != 'MyISAM'
+
+    @cached_property
+    def has_zoneinfo_database(self):
+        # Test if the time zone definitions are installed.
+        with self.connection.cursor() as cursor:
+            cursor.execute("SELECT 1 FROM mysql.time_zone LIMIT 1")
+            return cursor.fetchone() is not None
+
+    @cached_property
+    def is_sql_auto_is_null_enabled(self):
+        with self.connection.cursor() as cursor:
+            cursor.execute('SELECT @@SQL_AUTO_IS_NULL')
+            result = cursor.fetchone()
+            return result and result[0] == 1
+
+    @cached_property
+    def supports_over_clause(self):
+        if self.connection.mysql_is_mariadb:
+            return self.connection.mysql_version >= (10, 2)
+        return self.connection.mysql_version >= (8, 0, 2)
+
+    @cached_property
+    def has_select_for_update_skip_locked(self):
+        return not self.connection.mysql_is_mariadb and self.connection.mysql_version >= (8, 0, 1)
+
+    has_select_for_update_nowait = property(operator.attrgetter('has_select_for_update_skip_locked'))
+
+    @cached_property
+    def needs_explain_extended(self):
+        # EXTENDED is deprecated (and not required) in MySQL 5.7.
+        return not self.connection.mysql_is_mariadb and self.connection.mysql_version < (5, 7)
+
+    @cached_property
+    def supports_transactions(self):
+        """
+        All storage engines except MyISAM support transactions.
+        """
+        return self._mysql_storage_engine != 'MyISAM'
+
+    @cached_property
+    def ignores_table_name_case(self):
+        with self.connection.cursor() as cursor:
+            cursor.execute('SELECT @@LOWER_CASE_TABLE_NAMES')
+            result = cursor.fetchone()
+            return result and result[0] != 0
+
+    @cached_property
+    def supports_default_in_lead_lag(self):
+        # To be added in https://jira.mariadb.org/browse/MDEV-12981.
+        return not self.connection.mysql_is_mariadb

venv/lib/python3.7/site-packages/django/db/backends/mysql/operations.py

@@ -0,0 +1,306 @@
+import uuid
+
+from django.conf import settings
+from django.db.backends.base.operations import BaseDatabaseOperations
+from django.utils import timezone
+from django.utils.duration import duration_microseconds
+
+
+class DatabaseOperations(BaseDatabaseOperations):
+    compiler_module = "django.db.backends.mysql.compiler"
+
+    # MySQL stores positive fields as UNSIGNED ints.
+    integer_field_ranges = {
+        **BaseDatabaseOperations.integer_field_ranges,
+        'PositiveSmallIntegerField': (0, 65535),
+        'PositiveIntegerField': (0, 4294967295),
+    }
+    cast_data_types = {
+        'AutoField': 'signed integer',
+        'BigAutoField': 'signed integer',
+        'CharField': 'char(%(max_length)s)',
+        'DecimalField': 'decimal(%(max_digits)s, %(decimal_places)s)',
+        'TextField': 'char',
+        'IntegerField': 'signed integer',
+        'BigIntegerField': 'signed integer',
+        'SmallIntegerField': 'signed integer',
+        'PositiveIntegerField': 'unsigned integer',
+        'PositiveSmallIntegerField': 'unsigned integer',
+    }
+    cast_char_field_without_max_length = 'char'
+    explain_prefix = 'EXPLAIN'
+
+    def date_extract_sql(self, lookup_type, field_name):
+        # https://dev.mysql.com/doc/mysql/en/date-and-time-functions.html
+        if lookup_type == 'week_day':
+            # DAYOFWEEK() returns an integer, 1-7, Sunday=1.
+            # Note: WEEKDAY() returns 0-6, Monday=0.
+            return "DAYOFWEEK(%s)" % field_name
+        elif lookup_type == 'week':
+            # Override the value of default_week_format for consistency with
+            # other database backends.
+            # Mode 3: Monday, 1-53, with 4 or more days this year.
+            return "WEEK(%s, 3)" % field_name
+        elif lookup_type == 'iso_year':
+            # Get the year part from the YEARWEEK function, which returns a
+            # number as year * 100 + week.
+            return "TRUNCATE(YEARWEEK(%s, 3), -2) / 100" % field_name
+        else:
+            # EXTRACT returns 1-53 based on ISO-8601 for the week number.
+            return "EXTRACT(%s FROM %s)" % (lookup_type.upper(), field_name)
+
+    def date_trunc_sql(self, lookup_type, field_name):
+        fields = {
+            'year': '%%Y-01-01',
+            'month': '%%Y-%%m-01',
+        }  # Use double percents to escape.
+        if lookup_type in fields:
+            format_str = fields[lookup_type]
+            return "CAST(DATE_FORMAT(%s, '%s') AS DATE)" % (field_name, format_str)
+        elif lookup_type == 'quarter':
+            return "MAKEDATE(YEAR(%s), 1) + INTERVAL QUARTER(%s) QUARTER - INTERVAL 1 QUARTER" % (
+                field_name, field_name
+            )
+        elif lookup_type == 'week':
+            return "DATE_SUB(%s, INTERVAL WEEKDAY(%s) DAY)" % (
+                field_name, field_name
+            )
+        else:
+            return "DATE(%s)" % (field_name)
+
+    def _convert_field_to_tz(self, field_name, tzname):
+        if settings.USE_TZ:
+            field_name = "CONVERT_TZ(%s, 'UTC', '%s')" % (field_name, tzname)
+        return field_name
+
+    def datetime_cast_date_sql(self, field_name, tzname):
+        field_name = self._convert_field_to_tz(field_name, tzname)
+        return "DATE(%s)" % field_name
+
+    def datetime_cast_time_sql(self, field_name, tzname):
+        field_name = self._convert_field_to_tz(field_name, tzname)
+        return "TIME(%s)" % field_name
+
+    def datetime_extract_sql(self, lookup_type, field_name, tzname):
+        field_name = self._convert_field_to_tz(field_name, tzname)
+        return self.date_extract_sql(lookup_type, field_name)
+
+    def datetime_trunc_sql(self, lookup_type, field_name, tzname):
+        field_name = self._convert_field_to_tz(field_name, tzname)
+        fields = ['year', 'month', 'day', 'hour', 'minute', 'second']
+        format = ('%%Y-', '%%m', '-%%d', ' %%H:', '%%i', ':%%s')  # Use double percents to escape.
+        format_def = ('0000-', '01', '-01', ' 00:', '00', ':00')
+        if lookup_type == 'quarter':
+            return (
+                "CAST(DATE_FORMAT(MAKEDATE(YEAR({field_name}), 1) + "
+                "INTERVAL QUARTER({field_name}) QUARTER - " +
+                "INTERVAL 1 QUARTER, '%%Y-%%m-01 00:00:00') AS DATETIME)"
+            ).format(field_name=field_name)
+        if lookup_type == 'week':
+            return (
+                "CAST(DATE_FORMAT(DATE_SUB({field_name}, "
+                "INTERVAL WEEKDAY({field_name}) DAY), "
+                "'%%Y-%%m-%%d 00:00:00') AS DATETIME)"
+            ).format(field_name=field_name)
+        try:
+            i = fields.index(lookup_type) + 1
+        except ValueError:
+            sql = field_name
+        else:
+            format_str = ''.join([f for f in format[:i]] + [f for f in format_def[i:]])
+            sql = "CAST(DATE_FORMAT(%s, '%s') AS DATETIME)" % (field_name, format_str)
+        return sql
+
+    def time_trunc_sql(self, lookup_type, field_name):
+        fields = {
+            'hour': '%%H:00:00',
+            'minute': '%%H:%%i:00',
+            'second': '%%H:%%i:%%s',
+        }  # Use double percents to escape.
+        if lookup_type in fields:
+            format_str = fields[lookup_type]
+            return "CAST(DATE_FORMAT(%s, '%s') AS TIME)" % (field_name, format_str)
+        else:
+            return "TIME(%s)" % (field_name)
+
+    def date_interval_sql(self, timedelta):
+        return 'INTERVAL %s MICROSECOND' % duration_microseconds(timedelta)
+
+    def format_for_duration_arithmetic(self, sql):
+        return 'INTERVAL %s MICROSECOND' % sql
+
+    def force_no_ordering(self):
+        """
+        "ORDER BY NULL" prevents MySQL from implicitly ordering by grouped
+        columns. If no ordering would otherwise be applied, we don't want any
+        implicit sorting going on.
+        """
+        return [(None, ("NULL", [], False))]
+
+    def last_executed_query(self, cursor, sql, params):
+        # With MySQLdb, cursor objects have an (undocumented) "_executed"
+        # attribute where the exact query sent to the database is saved.
+        # See MySQLdb/cursors.py in the source distribution.
+        query = getattr(cursor, '_executed', None)
+        if query is not None:
+            query = query.decode(errors='replace')
+        return query
+
+    def no_limit_value(self):
+        # 2**64 - 1, as recommended by the MySQL documentation
+        return 18446744073709551615
+
+    def quote_name(self, name):
+        if name.startswith("`") and name.endswith("`"):
+            return name  # Quoting once is enough.
+        return "`%s`" % name
+
+    def random_function_sql(self):
+        return 'RAND()'
+
+    def sql_flush(self, style, tables, sequences, allow_cascade=False):
+        # NB: The generated SQL below is specific to MySQL
+        # 'TRUNCATE x;', 'TRUNCATE y;', 'TRUNCATE z;'... style SQL statements
+        # to clear all tables of all data
+        if tables:
+            sql = ['SET FOREIGN_KEY_CHECKS = 0;']
+            for table in tables:
+                sql.append('%s %s;' % (
+                    style.SQL_KEYWORD('TRUNCATE'),
+                    style.SQL_FIELD(self.quote_name(table)),
+                ))
+            sql.append('SET FOREIGN_KEY_CHECKS = 1;')
+            sql.extend(self.sequence_reset_by_name_sql(style, sequences))
+            return sql
+        else:
+            return []
+
+    def validate_autopk_value(self, value):
+        # MySQLism: zero in AUTO_INCREMENT field does not work. Refs #17653.
+        if value == 0:
+            raise ValueError('The database backend does not accept 0 as a '
+                             'value for AutoField.')
+        return value
+
+    def adapt_datetimefield_value(self, value):
+        if value is None:
+            return None
+
+        # Expression values are adapted by the database.
+        if hasattr(value, 'resolve_expression'):
+            return value
+
+        # MySQL doesn't support tz-aware datetimes
+        if timezone.is_aware(value):
+            if settings.USE_TZ:
+                value = timezone.make_naive(value, self.connection.timezone)
+            else:
+                raise ValueError("MySQL backend does not support timezone-aware datetimes when USE_TZ is False.")
+        return str(value)
+
+    def adapt_timefield_value(self, value):
+        if value is None:
+            return None
+
+        # Expression values are adapted by the database.
+        if hasattr(value, 'resolve_expression'):
+            return value
+
+        # MySQL doesn't support tz-aware times
+        if timezone.is_aware(value):
+            raise ValueError("MySQL backend does not support timezone-aware times.")
+
+        return str(value)
+
+    def max_name_length(self):
+        return 64
+
+    def bulk_insert_sql(self, fields, placeholder_rows):
+        placeholder_rows_sql = (", ".join(row) for row in placeholder_rows)
+        values_sql = ", ".join("(%s)" % sql for sql in placeholder_rows_sql)
+        return "VALUES " + values_sql
+
+    def combine_expression(self, connector, sub_expressions):
+        if connector == '^':
+            return 'POW(%s)' % ','.join(sub_expressions)
+        # Convert the result to a signed integer since MySQL's binary operators
+        # return an unsigned integer.
+        elif connector in ('&', '|', '<<'):
+            return 'CONVERT(%s, SIGNED)' % connector.join(sub_expressions)
+        elif connector == '>>':
+            lhs, rhs = sub_expressions
+            return 'FLOOR(%(lhs)s / POW(2, %(rhs)s))' % {'lhs': lhs, 'rhs': rhs}
+        return super().combine_expression(connector, sub_expressions)
+
+    def get_db_converters(self, expression):
+        converters = super().get_db_converters(expression)
+        internal_type = expression.output_field.get_internal_type()
+        if internal_type in ['BooleanField', 'NullBooleanField']:
+            converters.append(self.convert_booleanfield_value)
+        elif internal_type == 'DateTimeField':
+            if settings.USE_TZ:
+                converters.append(self.convert_datetimefield_value)
+        elif internal_type == 'UUIDField':
+            converters.append(self.convert_uuidfield_value)
+        return converters
+
+    def convert_booleanfield_value(self, value, expression, connection):
+        if value in (0, 1):
+            value = bool(value)
+        return value
+
+    def convert_datetimefield_value(self, value, expression, connection):
+        if value is not None:
+            value = timezone.make_aware(value, self.connection.timezone)
+        return value
+
+    def convert_uuidfield_value(self, value, expression, connection):
+        if value is not None:
+            value = uuid.UUID(value)
+        return value
+
+    def binary_placeholder_sql(self, value):
+        return '_binary %s' if value is not None and not hasattr(value, 'as_sql') else '%s'
+
+    def subtract_temporals(self, internal_type, lhs, rhs):
+        lhs_sql, lhs_params = lhs
+        rhs_sql, rhs_params = rhs
+        if internal_type == 'TimeField':
+            if self.connection.mysql_is_mariadb:
+                # MariaDB includes the microsecond component in TIME_TO_SEC as
+                # a decimal. MySQL returns an integer without microseconds.
+                return 'CAST((TIME_TO_SEC(%(lhs)s) - TIME_TO_SEC(%(rhs)s)) * 1000000 AS SIGNED)' % {
+                    'lhs': lhs_sql, 'rhs': rhs_sql
+                }, lhs_params + rhs_params
+            return (
+                "((TIME_TO_SEC(%(lhs)s) * 1000000 + MICROSECOND(%(lhs)s)) -"
+                " (TIME_TO_SEC(%(rhs)s) * 1000000 + MICROSECOND(%(rhs)s)))"
+            ) % {'lhs': lhs_sql, 'rhs': rhs_sql}, lhs_params * 2 + rhs_params * 2
+        else:
+            return "TIMESTAMPDIFF(MICROSECOND, %s, %s)" % (rhs_sql, lhs_sql), rhs_params + lhs_params
+
+    def explain_query_prefix(self, format=None, **options):
+        # Alias MySQL's TRADITIONAL to TEXT for consistency with other backends.
+        if format and format.upper() == 'TEXT':
+            format = 'TRADITIONAL'
+        prefix = super().explain_query_prefix(format, **options)
+        if format:
+            prefix += ' FORMAT=%s' % format
+        if self.connection.features.needs_explain_extended and format is None:
+            # EXTENDED and FORMAT are mutually exclusive options.
+            prefix += ' EXTENDED'
+        return prefix
+
+    def regex_lookup(self, lookup_type):
+        # REGEXP BINARY doesn't work correctly in MySQL 8+ and REGEXP_LIKE
+        # doesn't exist in MySQL 5.6 or in MariaDB.
+        if self.connection.mysql_version < (8, 0, 0) or self.connection.mysql_is_mariadb:
+            if lookup_type == 'regex':
+                return '%s REGEXP BINARY %s'
+            return '%s REGEXP %s'
+
+        match_option = 'c' if lookup_type == 'regex' else 'i'
+        return "REGEXP_LIKE(%%s, %%s, '%s')" % match_option
+
+    def insert_statement(self, ignore_conflicts=False):
+        return 'INSERT IGNORE INTO' if ignore_conflicts else super().insert_statement(ignore_conflicts)

venv/lib/python3.7/site-packages/django/db/backends/mysql/schema.py

@@ -0,0 +1,103 @@
+from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+from django.db.models import NOT_PROVIDED
+
+
+class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
+
+    sql_rename_table = "RENAME TABLE %(old_table)s TO %(new_table)s"
+
+    sql_alter_column_null = "MODIFY %(column)s %(type)s NULL"
+    sql_alter_column_not_null = "MODIFY %(column)s %(type)s NOT NULL"
+    sql_alter_column_type = "MODIFY %(column)s %(type)s"
+
+    # No 'CASCADE' which works as a no-op in MySQL but is undocumented
+    sql_delete_column = "ALTER TABLE %(table)s DROP COLUMN %(column)s"
+
+    sql_rename_column = "ALTER TABLE %(table)s CHANGE %(old_column)s %(new_column)s %(type)s"
+
+    sql_delete_unique = "ALTER TABLE %(table)s DROP INDEX %(name)s"
+
+    sql_delete_fk = "ALTER TABLE %(table)s DROP FOREIGN KEY %(name)s"
+
+    sql_delete_index = "DROP INDEX %(name)s ON %(table)s"
+
+    sql_create_pk = "ALTER TABLE %(table)s ADD CONSTRAINT %(name)s PRIMARY KEY (%(columns)s)"
+    sql_delete_pk = "ALTER TABLE %(table)s DROP PRIMARY KEY"
+
+    sql_create_index = 'CREATE INDEX %(name)s ON %(table)s (%(columns)s)%(extra)s'
+
+    def quote_value(self, value):
+        self.connection.ensure_connection()
+        quoted = self.connection.connection.escape(value, self.connection.connection.encoders)
+        if isinstance(value, str):
+            quoted = quoted.decode()
+        return quoted
+
+    def _is_limited_data_type(self, field):
+        db_type = field.db_type(self.connection)
+        return db_type is not None and db_type.lower() in self.connection._limited_data_types
+
+    def skip_default(self, field):
+        return self._is_limited_data_type(field)
+
+    def add_field(self, model, field):
+        super().add_field(model, field)
+
+        # Simulate the effect of a one-off default.
+        # field.default may be unhashable, so a set isn't used for "in" check.
+        if self.skip_default(field) and field.default not in (None, NOT_PROVIDED):
+            effective_default = self.effective_default(field)
+            self.execute('UPDATE %(table)s SET %(column)s = %%s' % {
+                'table': self.quote_name(model._meta.db_table),
+                'column': self.quote_name(field.column),
+            }, [effective_default])
+
+    def _field_should_be_indexed(self, model, field):
+        create_index = super()._field_should_be_indexed(model, field)
+        storage = self.connection.introspection.get_storage_engine(
+            self.connection.cursor(), model._meta.db_table
+        )
+        # No need to create an index for ForeignKey fields except if
+        # db_constraint=False because the index from that constraint won't be
+        # created.
+        if (storage == "InnoDB" and
+                create_index and
+                field.get_internal_type() == 'ForeignKey' and
+                field.db_constraint):
+            return False
+        return not self._is_limited_data_type(field) and create_index
+
+    def _delete_composed_index(self, model, fields, *args):
+        """
+        MySQL can remove an implicit FK index on a field when that field is
+        covered by another index like a unique_together. "covered" here means
+        that the more complex index starts like the simpler one.
+        http://bugs.mysql.com/bug.php?id=37910 / Django ticket #24757
+        We check here before removing the [unique|index]_together if we have to
+        recreate a FK index.
+        """
+        first_field = model._meta.get_field(fields[0])
+        if first_field.get_internal_type() == 'ForeignKey':
+            constraint_names = self._constraint_names(model, [first_field.column], index=True)
+            if not constraint_names:
+                self.execute(self._create_index_sql(model, [first_field], suffix=""))
+        return super()._delete_composed_index(model, fields, *args)
+
+    def _set_field_new_type_null_status(self, field, new_type):
+        """
+        Keep the null property of the old field. If it has changed, it will be
+        handled separately.
+        """
+        if field.null:
+            new_type += " NULL"
+        else:
+            new_type += " NOT NULL"
+        return new_type
+
+    def _alter_column_type_sql(self, model, old_field, new_field, new_type):
+        new_type = self._set_field_new_type_null_status(old_field, new_type)
+        return super()._alter_column_type_sql(model, old_field, new_field, new_type)
+
+    def _rename_field_sql(self, table, old_field, new_field, new_type):
+        new_type = self._set_field_new_type_null_status(old_field, new_type)
+        return super()._rename_field_sql(table, old_field, new_field, new_type)

venv/lib/python3.7/site-packages/django/db/backends/oracle/client.py

@@ -0,0 +1,17 @@
+import shutil
+import subprocess
+
+from django.db.backends.base.client import BaseDatabaseClient
+
+
+class DatabaseClient(BaseDatabaseClient):
+    executable_name = 'sqlplus'
+    wrapper_name = 'rlwrap'
+
+    def runshell(self):
+        conn_string = self.connection._connect_string()
+        args = [self.executable_name, "-L", conn_string]
+        wrapper_path = shutil.which(self.wrapper_name)
+        if wrapper_path:
+            args = [wrapper_path, *args]
+        subprocess.check_call(args)

venv/lib/python3.7/site-packages/django/db/backends/oracle/features.py

@@ -0,0 +1,71 @@
+from django.db.backends.base.features import BaseDatabaseFeatures
+from django.db.utils import InterfaceError
+from django.utils.functional import cached_property
+
+
+class DatabaseFeatures(BaseDatabaseFeatures):
+    interprets_empty_strings_as_nulls = True
+    has_select_for_update = True
+    has_select_for_update_nowait = True
+    has_select_for_update_skip_locked = True
+    has_select_for_update_of = True
+    select_for_update_of_column = True
+    can_return_id_from_insert = True
+    can_introspect_autofield = True
+    supports_subqueries_in_group_by = False
+    supports_transactions = True
+    supports_timezones = False
+    has_native_duration_field = True
+    can_defer_constraint_checks = True
+    supports_partially_nullable_unique_constraints = False
+    truncates_names = True
+    supports_tablespaces = True
+    supports_sequence_reset = False
+    can_introspect_materialized_views = True
+    can_introspect_time_field = False
+    atomic_transactions = False
+    supports_combined_alters = False
+    nulls_order_largest = True
+    requires_literal_defaults = True
+    closed_cursor_error_class = InterfaceError
+    bare_select_suffix = " FROM DUAL"
+    # select for update with limit can be achieved on Oracle, but not with the current backend.
+    supports_select_for_update_with_limit = False
+    supports_temporal_subtraction = True
+    # Oracle doesn't ignore quoted identifiers case but the current backend
+    # does by uppercasing all identifiers.
+    ignores_table_name_case = True
+    supports_index_on_text_field = False
+    has_case_insensitive_like = False
+    create_test_procedure_without_params_sql = """
+        CREATE PROCEDURE "TEST_PROCEDURE" AS
+            V_I INTEGER;
+        BEGIN
+            V_I := 1;
+        END;
+    """
+    create_test_procedure_with_int_param_sql = """
+        CREATE PROCEDURE "TEST_PROCEDURE" (P_I INTEGER) AS
+            V_I INTEGER;
+        BEGIN
+            V_I := P_I;
+        END;
+    """
+    supports_callproc_kwargs = True
+    supports_over_clause = True
+    supports_ignore_conflicts = False
+    max_query_params = 2**16 - 1
+    supports_partial_indexes = False
+    allows_multiple_constraints_on_same_fields = False
+
+    @cached_property
+    def has_fetch_offset_support(self):
+        return self.connection.oracle_version >= (12, 2)
+
+    @cached_property
+    def allow_sliced_subqueries_with_in(self):
+        return self.has_fetch_offset_support
+
+    @cached_property
+    def supports_slicing_ordering_in_compound(self):
+        return self.has_fetch_offset_support

venv/lib/python3.7/site-packages/django/db/backends/oracle/functions.py

@@ -0,0 +1,22 @@
+from django.db.models import DecimalField, DurationField, Func
+
+
+class IntervalToSeconds(Func):
+    function = ''
+    template = """
+    EXTRACT(day from %(expressions)s) * 86400 +
+    EXTRACT(hour from %(expressions)s) * 3600 +
+    EXTRACT(minute from %(expressions)s) * 60 +
+    EXTRACT(second from %(expressions)s)
+    """
+
+    def __init__(self, expression, *, output_field=None, **extra):
+        super().__init__(expression, output_field=output_field or DecimalField(), **extra)
+
+
+class SecondsToInterval(Func):
+    function = 'NUMTODSINTERVAL'
+    template = "%(function)s(%(expressions)s, 'SECOND')"
+
+    def __init__(self, expression, *, output_field=None, **extra):
+        super().__init__(expression, output_field=output_field or DurationField(), **extra)

venv/lib/python3.7/site-packages/django/db/backends/postgresql/base.py

@@ -0,0 +1,283 @@
+"""
+PostgreSQL database backend for Django.
+
+Requires psycopg 2: http://initd.org/projects/psycopg2
+"""
+
+import threading
+import warnings
+
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+from django.db import connections
+from django.db.backends.base.base import BaseDatabaseWrapper
+from django.db.utils import DatabaseError as WrappedDatabaseError
+from django.utils.functional import cached_property
+from django.utils.safestring import SafeText
+from django.utils.version import get_version_tuple
+
+try:
+    import psycopg2 as Database
+    import psycopg2.extensions
+    import psycopg2.extras
+except ImportError as e:
+    raise ImproperlyConfigured("Error loading psycopg2 module: %s" % e)
+
+
+def psycopg2_version():
+    version = psycopg2.__version__.split(' ', 1)[0]
+    return get_version_tuple(version)
+
+
+PSYCOPG2_VERSION = psycopg2_version()
+
+if PSYCOPG2_VERSION < (2, 5, 4):
+    raise ImproperlyConfigured("psycopg2_version 2.5.4 or newer is required; you have %s" % psycopg2.__version__)
+
+
+# Some of these import psycopg2, so import them after checking if it's installed.
+from .client import DatabaseClient                          # NOQA isort:skip
+from .creation import DatabaseCreation                      # NOQA isort:skip
+from .features import DatabaseFeatures                      # NOQA isort:skip
+from .introspection import DatabaseIntrospection            # NOQA isort:skip
+from .operations import DatabaseOperations                  # NOQA isort:skip
+from .schema import DatabaseSchemaEditor                    # NOQA isort:skip
+from .utils import utc_tzinfo_factory                       # NOQA isort:skip
+
+psycopg2.extensions.register_adapter(SafeText, psycopg2.extensions.QuotedString)
+psycopg2.extras.register_uuid()
+
+# Register support for inet[] manually so we don't have to handle the Inet()
+# object on load all the time.
+INETARRAY_OID = 1041
+INETARRAY = psycopg2.extensions.new_array_type(
+    (INETARRAY_OID,),
+    'INETARRAY',
+    psycopg2.extensions.UNICODE,
+)
+psycopg2.extensions.register_type(INETARRAY)
+
+
+class DatabaseWrapper(BaseDatabaseWrapper):
+    vendor = 'postgresql'
+    display_name = 'PostgreSQL'
+    # This dictionary maps Field objects to their associated PostgreSQL column
+    # types, as strings. Column-type strings can contain format strings; they'll
+    # be interpolated against the values of Field.__dict__ before being output.
+    # If a column type is set to None, it won't be included in the output.
+    data_types = {
+        'AutoField': 'serial',
+        'BigAutoField': 'bigserial',
+        'BinaryField': 'bytea',
+        'BooleanField': 'boolean',
+        'CharField': 'varchar(%(max_length)s)',
+        'DateField': 'date',
+        'DateTimeField': 'timestamp with time zone',
+        'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
+        'DurationField': 'interval',
+        'FileField': 'varchar(%(max_length)s)',
+        'FilePathField': 'varchar(%(max_length)s)',
+        'FloatField': 'double precision',
+        'IntegerField': 'integer',
+        'BigIntegerField': 'bigint',
+        'IPAddressField': 'inet',
+        'GenericIPAddressField': 'inet',
+        'NullBooleanField': 'boolean',
+        'OneToOneField': 'integer',
+        'PositiveIntegerField': 'integer',
+        'PositiveSmallIntegerField': 'smallint',
+        'SlugField': 'varchar(%(max_length)s)',
+        'SmallIntegerField': 'smallint',
+        'TextField': 'text',
+        'TimeField': 'time',
+        'UUIDField': 'uuid',
+    }
+    data_type_check_constraints = {
+        'PositiveIntegerField': '"%(column)s" >= 0',
+        'PositiveSmallIntegerField': '"%(column)s" >= 0',
+    }
+    operators = {
+        'exact': '= %s',
+        'iexact': '= UPPER(%s)',
+        'contains': 'LIKE %s',
+        'icontains': 'LIKE UPPER(%s)',
+        'regex': '~ %s',
+        'iregex': '~* %s',
+        'gt': '> %s',
+        'gte': '>= %s',
+        'lt': '< %s',
+        'lte': '<= %s',
+        'startswith': 'LIKE %s',
+        'endswith': 'LIKE %s',
+        'istartswith': 'LIKE UPPER(%s)',
+        'iendswith': 'LIKE UPPER(%s)',
+    }
+
+    # The patterns below are used to generate SQL pattern lookup clauses when
+    # the right-hand side of the lookup isn't a raw string (it might be an expression
+    # or the result of a bilateral transformation).
+    # In those cases, special characters for LIKE operators (e.g. \, *, _) should be
+    # escaped on database side.
+    #
+    # Note: we use str.format() here for readability as '%' is used as a wildcard for
+    # the LIKE operator.
+    pattern_esc = r"REPLACE(REPLACE(REPLACE({}, E'\\', E'\\\\'), E'%%', E'\\%%'), E'_', E'\\_')"
+    pattern_ops = {
+        'contains': "LIKE '%%' || {} || '%%'",
+        'icontains': "LIKE '%%' || UPPER({}) || '%%'",
+        'startswith': "LIKE {} || '%%'",
+        'istartswith': "LIKE UPPER({}) || '%%'",
+        'endswith': "LIKE '%%' || {}",
+        'iendswith': "LIKE '%%' || UPPER({})",
+    }
+
+    Database = Database
+    SchemaEditorClass = DatabaseSchemaEditor
+    # Classes instantiated in __init__().
+    client_class = DatabaseClient
+    creation_class = DatabaseCreation
+    features_class = DatabaseFeatures
+    introspection_class = DatabaseIntrospection
+    ops_class = DatabaseOperations
+    # PostgreSQL backend-specific attributes.
+    _named_cursor_idx = 0
+
+    def get_connection_params(self):
+        settings_dict = self.settings_dict
+        # None may be used to connect to the default 'postgres' db
+        if settings_dict['NAME'] == '':
+            raise ImproperlyConfigured(
+                "settings.DATABASES is improperly configured. "
+                "Please supply the NAME value.")
+        if len(settings_dict['NAME'] or '') > self.ops.max_name_length():
+            raise ImproperlyConfigured(
+                "The database name '%s' (%d characters) is longer than "
+                "PostgreSQL's limit of %d characters. Supply a shorter NAME "
+                "in settings.DATABASES." % (
+                    settings_dict['NAME'],
+                    len(settings_dict['NAME']),
+                    self.ops.max_name_length(),
+                )
+            )
+        conn_params = {
+            'database': settings_dict['NAME'] or 'postgres',
+            **settings_dict['OPTIONS'],
+        }
+        conn_params.pop('isolation_level', None)
+        if settings_dict['USER']:
+            conn_params['user'] = settings_dict['USER']
+        if settings_dict['PASSWORD']:
+            conn_params['password'] = settings_dict['PASSWORD']
+        if settings_dict['HOST']:
+            conn_params['host'] = settings_dict['HOST']
+        if settings_dict['PORT']:
+            conn_params['port'] = settings_dict['PORT']
+        return conn_params
+
+    def get_new_connection(self, conn_params):
+        connection = Database.connect(**conn_params)
+
+        # self.isolation_level must be set:
+        # - after connecting to the database in order to obtain the database's
+        #   default when no value is explicitly specified in options.
+        # - before calling _set_autocommit() because if autocommit is on, that
+        #   will set connection.isolation_level to ISOLATION_LEVEL_AUTOCOMMIT.
+        options = self.settings_dict['OPTIONS']
+        try:
+            self.isolation_level = options['isolation_level']
+        except KeyError:
+            self.isolation_level = connection.isolation_level
+        else:
+            # Set the isolation level to the value from OPTIONS.
+            if self.isolation_level != connection.isolation_level:
+                connection.set_session(isolation_level=self.isolation_level)
+
+        return connection
+
+    def ensure_timezone(self):
+        if self.connection is None:
+            return False
+        conn_timezone_name = self.connection.get_parameter_status('TimeZone')
+        timezone_name = self.timezone_name
+        if timezone_name and conn_timezone_name != timezone_name:
+            with self.connection.cursor() as cursor:
+                cursor.execute(self.ops.set_time_zone_sql(), [timezone_name])
+            return True
+        return False
+
+    def init_connection_state(self):
+        self.connection.set_client_encoding('UTF8')
+
+        timezone_changed = self.ensure_timezone()
+        if timezone_changed:
+            # Commit after setting the time zone (see #17062)
+            if not self.get_autocommit():
+                self.connection.commit()
+
+    def create_cursor(self, name=None):
+        if name:
+            # In autocommit mode, the cursor will be used outside of a
+            # transaction, hence use a holdable cursor.
+            cursor = self.connection.cursor(name, scrollable=False, withhold=self.connection.autocommit)
+        else:
+            cursor = self.connection.cursor()
+        cursor.tzinfo_factory = utc_tzinfo_factory if settings.USE_TZ else None
+        return cursor
+
+    def chunked_cursor(self):
+        self._named_cursor_idx += 1
+        return self._cursor(
+            name='_django_curs_%d_%d' % (
+                # Avoid reusing name in other threads
+                threading.current_thread().ident,
+                self._named_cursor_idx,
+            )
+        )
+
+    def _set_autocommit(self, autocommit):
+        with self.wrap_database_errors:
+            self.connection.autocommit = autocommit
+
+    def check_constraints(self, table_names=None):
+        """
+        Check constraints by setting them to immediate. Return them to deferred
+        afterward.
+        """
+        self.cursor().execute('SET CONSTRAINTS ALL IMMEDIATE')
+        self.cursor().execute('SET CONSTRAINTS ALL DEFERRED')
+
+    def is_usable(self):
+        try:
+            # Use a psycopg cursor directly, bypassing Django's utilities.
+            self.connection.cursor().execute("SELECT 1")
+        except Database.Error:
+            return False
+        else:
+            return True
+
+    @property
+    def _nodb_connection(self):
+        nodb_connection = super()._nodb_connection
+        try:
+            nodb_connection.ensure_connection()
+        except (Database.DatabaseError, WrappedDatabaseError):
+            warnings.warn(
+                "Normally Django will use a connection to the 'postgres' database "
+                "to avoid running initialization queries against the production "
+                "database when it's not needed (for example, when running tests). "
+                "Django was unable to create a connection to the 'postgres' database "
+                "and will use the first PostgreSQL database instead.",
+                RuntimeWarning
+            )
+            for connection in connections.all():
+                if connection.vendor == 'postgresql' and connection.settings_dict['NAME'] != 'postgres':
+                    return self.__class__(
+                        {**self.settings_dict, 'NAME': connection.settings_dict['NAME']},
+                        alias=self.alias,
+                    )
+        return nodb_connection
+
+    @cached_property
+    def pg_version(self):
+        with self.temporary_connection():
+            return self.connection.server_version

venv/lib/python3.7/site-packages/django/db/backends/postgresql/client.py

@@ -0,0 +1,71 @@
+import os
+import signal
+import subprocess
+
+from django.core.files.temp import NamedTemporaryFile
+from django.db.backends.base.client import BaseDatabaseClient
+
+
+def _escape_pgpass(txt):
+    """
+    Escape a fragment of a PostgreSQL .pgpass file.
+    """
+    return txt.replace('\\', '\\\\').replace(':', '\\:')
+
+
+class DatabaseClient(BaseDatabaseClient):
+    executable_name = 'psql'
+
+    @classmethod
+    def runshell_db(cls, conn_params):
+        args = [cls.executable_name]
+
+        host = conn_params.get('host', '')
+        port = conn_params.get('port', '')
+        dbname = conn_params.get('database', '')
+        user = conn_params.get('user', '')
+        passwd = conn_params.get('password', '')
+
+        if user:
+            args += ['-U', user]
+        if host:
+            args += ['-h', host]
+        if port:
+            args += ['-p', str(port)]
+        args += [dbname]
+
+        temp_pgpass = None
+        sigint_handler = signal.getsignal(signal.SIGINT)
+        try:
+            if passwd:
+                # Create temporary .pgpass file.
+                temp_pgpass = NamedTemporaryFile(mode='w+')
+                try:
+                    print(
+                        _escape_pgpass(host) or '*',
+                        str(port) or '*',
+                        _escape_pgpass(dbname) or '*',
+                        _escape_pgpass(user) or '*',
+                        _escape_pgpass(passwd),
+                        file=temp_pgpass,
+                        sep=':',
+                        flush=True,
+                    )
+                    os.environ['PGPASSFILE'] = temp_pgpass.name
+                except UnicodeEncodeError:
+                    # If the current locale can't encode the data, let the
+                    # user input the password manually.
+                    pass
+            # Allow SIGINT to pass to psql to abort queries.
+            signal.signal(signal.SIGINT, signal.SIG_IGN)
+            subprocess.check_call(args)
+        finally:
+            # Restore the original SIGINT handler.
+            signal.signal(signal.SIGINT, sigint_handler)
+            if temp_pgpass:
+                temp_pgpass.close()
+                if 'PGPASSFILE' in os.environ:  # unit tests need cleanup
+                    del os.environ['PGPASSFILE']
+
+    def runshell(self):
+        DatabaseClient.runshell_db(self.connection.get_connection_params())

venv/lib/python3.7/site-packages/django/db/backends/postgresql/creation.py

@@ -0,0 +1,77 @@
+import sys
+
+from psycopg2 import errorcodes
+
+from django.db.backends.base.creation import BaseDatabaseCreation
+from django.db.backends.utils import strip_quotes
+
+
+class DatabaseCreation(BaseDatabaseCreation):
+
+    def _quote_name(self, name):
+        return self.connection.ops.quote_name(name)
+
+    def _get_database_create_suffix(self, encoding=None, template=None):
+        suffix = ""
+        if encoding:
+            suffix += " ENCODING '{}'".format(encoding)
+        if template:
+            suffix += " TEMPLATE {}".format(self._quote_name(template))
+        return suffix and "WITH" + suffix
+
+    def sql_table_creation_suffix(self):
+        test_settings = self.connection.settings_dict['TEST']
+        assert test_settings['COLLATION'] is None, (
+            "PostgreSQL does not support collation setting at database creation time."
+        )
+        return self._get_database_create_suffix(
+            encoding=test_settings['CHARSET'],
+            template=test_settings.get('TEMPLATE'),
+        )
+
+    def _database_exists(self, cursor, database_name):
+        cursor.execute('SELECT 1 FROM pg_catalog.pg_database WHERE datname = %s', [strip_quotes(database_name)])
+        return cursor.fetchone() is not None
+
+    def _execute_create_test_db(self, cursor, parameters, keepdb=False):
+        try:
+            if keepdb and self._database_exists(cursor, parameters['dbname']):
+                # If the database should be kept and it already exists, don't
+                # try to create a new one.
+                return
+            super()._execute_create_test_db(cursor, parameters, keepdb)
+        except Exception as e:
+            if getattr(e.__cause__, 'pgcode', '') != errorcodes.DUPLICATE_DATABASE:
+                # All errors except "database already exists" cancel tests.
+                self.log('Got an error creating the test database: %s' % e)
+                sys.exit(2)
+            elif not keepdb:
+                # If the database should be kept, ignore "database already
+                # exists".
+                raise e
+
+    def _clone_test_db(self, suffix, verbosity, keepdb=False):
+        # CREATE DATABASE ... WITH TEMPLATE ... requires closing connections
+        # to the template database.
+        self.connection.close()
+
+        source_database_name = self.connection.settings_dict['NAME']
+        target_database_name = self.get_test_db_clone_settings(suffix)['NAME']
+        test_db_params = {
+            'dbname': self._quote_name(target_database_name),
+            'suffix': self._get_database_create_suffix(template=source_database_name),
+        }
+        with self._nodb_connection.cursor() as cursor:
+            try:
+                self._execute_create_test_db(cursor, test_db_params, keepdb)
+            except Exception:
+                try:
+                    if verbosity >= 1:
+                        self.log('Destroying old test database for alias %s...' % (
+                            self._get_database_display_str(verbosity, target_database_name),
+                        ))
+                    cursor.execute('DROP DATABASE %(dbname)s' % test_db_params)
+                    self._execute_create_test_db(cursor, test_db_params, keepdb)
+                except Exception as e:
+                    self.log('Got an error cloning the test database: %s' % e)
+                    sys.exit(2)

venv/lib/python3.7/site-packages/django/db/backends/postgresql/schema.py

@@ -0,0 +1,141 @@
+import psycopg2
+
+from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+from django.db.backends.ddl_references import IndexColumns
+
+
+class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
+
+    sql_alter_column_type = "ALTER COLUMN %(column)s TYPE %(type)s USING %(column)s::%(type)s"
+
+    sql_create_sequence = "CREATE SEQUENCE %(sequence)s"
+    sql_delete_sequence = "DROP SEQUENCE IF EXISTS %(sequence)s CASCADE"
+    sql_set_sequence_max = "SELECT setval('%(sequence)s', MAX(%(column)s)) FROM %(table)s"
+
+    sql_create_index = "CREATE INDEX %(name)s ON %(table)s%(using)s (%(columns)s)%(extra)s%(condition)s"
+    sql_delete_index = "DROP INDEX IF EXISTS %(name)s"
+
+    # Setting the constraint to IMMEDIATE runs any deferred checks to allow
+    # dropping it in the same transaction.
+    sql_delete_fk = "SET CONSTRAINTS %(name)s IMMEDIATE; ALTER TABLE %(table)s DROP CONSTRAINT %(name)s"
+
+    sql_delete_procedure = 'DROP FUNCTION %(procedure)s(%(param_types)s)'
+
+    def quote_value(self, value):
+        if isinstance(value, str):
+            value = value.replace('%', '%%')
+        # getquoted() returns a quoted bytestring of the adapted value.
+        return psycopg2.extensions.adapt(value).getquoted().decode()
+
+    def _field_indexes_sql(self, model, field):
+        output = super()._field_indexes_sql(model, field)
+        like_index_statement = self._create_like_index_sql(model, field)
+        if like_index_statement is not None:
+            output.append(like_index_statement)
+        return output
+
+    def _create_like_index_sql(self, model, field):
+        """
+        Return the statement to create an index with varchar operator pattern
+        when the column type is 'varchar' or 'text', otherwise return None.
+        """
+        db_type = field.db_type(connection=self.connection)
+        if db_type is not None and (field.db_index or field.unique):
+            # Fields with database column types of `varchar` and `text` need
+            # a second index that specifies their operator class, which is
+            # needed when performing correct LIKE queries outside the
+            # C locale. See #12234.
+            #
+            # The same doesn't apply to array fields such as varchar[size]
+            # and text[size], so skip them.
+            if '[' in db_type:
+                return None
+            if db_type.startswith('varchar'):
+                return self._create_index_sql(model, [field], suffix='_like', opclasses=['varchar_pattern_ops'])
+            elif db_type.startswith('text'):
+                return self._create_index_sql(model, [field], suffix='_like', opclasses=['text_pattern_ops'])
+        return None
+
+    def _alter_column_type_sql(self, model, old_field, new_field, new_type):
+        """Make ALTER TYPE with SERIAL make sense."""
+        table = model._meta.db_table
+        if new_type.lower() in ("serial", "bigserial"):
+            column = new_field.column
+            sequence_name = "%s_%s_seq" % (table, column)
+            col_type = "integer" if new_type.lower() == "serial" else "bigint"
+            return (
+                (
+                    self.sql_alter_column_type % {
+                        "column": self.quote_name(column),
+                        "type": col_type,
+                    },
+                    [],
+                ),
+                [
+                    (
+                        self.sql_delete_sequence % {
+                            "sequence": self.quote_name(sequence_name),
+                        },
+                        [],
+                    ),
+                    (
+                        self.sql_create_sequence % {
+                            "sequence": self.quote_name(sequence_name),
+                        },
+                        [],
+                    ),
+                    (
+                        self.sql_alter_column % {
+                            "table": self.quote_name(table),
+                            "changes": self.sql_alter_column_default % {
+                                "column": self.quote_name(column),
+                                "default": "nextval('%s')" % self.quote_name(sequence_name),
+                            }
+                        },
+                        [],
+                    ),
+                    (
+                        self.sql_set_sequence_max % {
+                            "table": self.quote_name(table),
+                            "column": self.quote_name(column),
+                            "sequence": self.quote_name(sequence_name),
+                        },
+                        [],
+                    ),
+                ],
+            )
+        else:
+            return super()._alter_column_type_sql(model, old_field, new_field, new_type)
+
+    def _alter_field(self, model, old_field, new_field, old_type, new_type,
+                     old_db_params, new_db_params, strict=False):
+        # Drop indexes on varchar/text/citext columns that are changing to a
+        # different type.
+        if (old_field.db_index or old_field.unique) and (
+            (old_type.startswith('varchar') and not new_type.startswith('varchar')) or
+            (old_type.startswith('text') and not new_type.startswith('text')) or
+            (old_type.startswith('citext') and not new_type.startswith('citext'))
+        ):
+            index_name = self._create_index_name(model._meta.db_table, [old_field.column], suffix='_like')
+            self.execute(self._delete_index_sql(model, index_name))
+
+        super()._alter_field(
+            model, old_field, new_field, old_type, new_type, old_db_params,
+            new_db_params, strict,
+        )
+        # Added an index? Create any PostgreSQL-specific indexes.
+        if ((not (old_field.db_index or old_field.unique) and new_field.db_index) or
+                (not old_field.unique and new_field.unique)):
+            like_index_statement = self._create_like_index_sql(model, new_field)
+            if like_index_statement is not None:
+                self.execute(like_index_statement)
+
+        # Removed an index? Drop any PostgreSQL-specific indexes.
+        if old_field.unique and not (new_field.db_index or new_field.unique):
+            index_to_remove = self._create_index_name(model._meta.db_table, [old_field.column], suffix='_like')
+            self.execute(self._delete_index_sql(model, index_to_remove))
+
+    def _index_columns(self, table, columns, col_suffixes, opclasses):
+        if opclasses:
+            return IndexColumns(table, columns, self.quote_name, col_suffixes=col_suffixes, opclasses=opclasses)
+        return super()._index_columns(table, columns, col_suffixes, opclasses)

venv/lib/python3.7/site-packages/django/db/backends/postgresql_psycopg2/client.py

@@ -0,0 +1 @@
+from ..postgresql.client import *  # NOQA

venv/lib/python3.7/site-packages/django/db/backends/postgresql_psycopg2/introspection.py

@@ -0,0 +1 @@
+from ..postgresql.introspection import *  # NOQA

venv/lib/python3.7/site-packages/django/db/backends/postgresql_psycopg2/operations.py

@@ -0,0 +1 @@
+from ..postgresql.operations import *  # NOQA

venv/lib/python3.7/site-packages/django/db/backends/postgresql_psycopg2/schema.py

@@ -0,0 +1 @@
+from ..postgresql.schema import *  # NOQA

venv/lib/python3.7/site-packages/django/db/backends/sqlite3/introspection.py

@@ -0,0 +1,434 @@
+import re
+from collections import namedtuple
+
+import sqlparse
+
+from django.db.backends.base.introspection import (
+    BaseDatabaseIntrospection, FieldInfo as BaseFieldInfo, TableInfo,
+)
+from django.db.models.indexes import Index
+
+FieldInfo = namedtuple('FieldInfo', BaseFieldInfo._fields + ('pk',))
+
+field_size_re = re.compile(r'^\s*(?:var)?char\s*\(\s*(\d+)\s*\)\s*$')
+
+
+def get_field_size(name):
+    """ Extract the size number from a "varchar(11)" type name """
+    m = field_size_re.search(name)
+    return int(m.group(1)) if m else None
+
+
+# This light wrapper "fakes" a dictionary interface, because some SQLite data
+# types include variables in them -- e.g. "varchar(30)" -- and can't be matched
+# as a simple dictionary lookup.
+class FlexibleFieldLookupDict:
+    # Maps SQL types to Django Field types. Some of the SQL types have multiple
+    # entries here because SQLite allows for anything and doesn't normalize the
+    # field type; it uses whatever was given.
+    base_data_types_reverse = {
+        'bool': 'BooleanField',
+        'boolean': 'BooleanField',
+        'smallint': 'SmallIntegerField',
+        'smallint unsigned': 'PositiveSmallIntegerField',
+        'smallinteger': 'SmallIntegerField',
+        'int': 'IntegerField',
+        'integer': 'IntegerField',
+        'bigint': 'BigIntegerField',
+        'integer unsigned': 'PositiveIntegerField',
+        'decimal': 'DecimalField',
+        'real': 'FloatField',
+        'text': 'TextField',
+        'char': 'CharField',
+        'varchar': 'CharField',
+        'blob': 'BinaryField',
+        'date': 'DateField',
+        'datetime': 'DateTimeField',
+        'time': 'TimeField',
+    }
+
+    def __getitem__(self, key):
+        key = key.lower().split('(', 1)[0].strip()
+        return self.base_data_types_reverse[key]
+
+
+class DatabaseIntrospection(BaseDatabaseIntrospection):
+    data_types_reverse = FlexibleFieldLookupDict()
+
+    def get_field_type(self, data_type, description):
+        field_type = super().get_field_type(data_type, description)
+        if description.pk and field_type in {'BigIntegerField', 'IntegerField'}:
+            # No support for BigAutoField as SQLite treats all integer primary
+            # keys as signed 64-bit integers.
+            return 'AutoField'
+        return field_type
+
+    def get_table_list(self, cursor):
+        """Return a list of table and view names in the current database."""
+        # Skip the sqlite_sequence system table used for autoincrement key
+        # generation.
+        cursor.execute("""
+            SELECT name, type FROM sqlite_master
+            WHERE type in ('table', 'view') AND NOT name='sqlite_sequence'
+            ORDER BY name""")
+        return [TableInfo(row[0], row[1][0]) for row in cursor.fetchall()]
+
+    def get_table_description(self, cursor, table_name):
+        """
+        Return a description of the table with the DB-API cursor.description
+        interface.
+        """
+        return [
+            FieldInfo(
+                info['name'],
+                info['type'],
+                None,
+                info['size'],
+                None,
+                None,
+                info['null_ok'],
+                info['default'],
+                info['pk'] == 1,
+            ) for info in self._table_info(cursor, table_name)
+        ]
+
+    def get_sequences(self, cursor, table_name, table_fields=()):
+        pk_col = self.get_primary_key_column(cursor, table_name)
+        return [{'table': table_name, 'column': pk_col}]
+
+    def get_relations(self, cursor, table_name):
+        """
+        Return a dictionary of {field_name: (field_name_other_table, other_table)}
+        representing all relationships to the given table.
+        """
+        # Dictionary of relations to return
+        relations = {}
+
+        # Schema for this table
+        cursor.execute(
+            "SELECT sql, type FROM sqlite_master "
+            "WHERE tbl_name = %s AND type IN ('table', 'view')",
+            [table_name]
+        )
+        create_sql, table_type = cursor.fetchone()
+        if table_type == 'view':
+            # It might be a view, then no results will be returned
+            return relations
+        results = create_sql[create_sql.index('(') + 1:create_sql.rindex(')')]
+
+        # Walk through and look for references to other tables. SQLite doesn't
+        # really have enforced references, but since it echoes out the SQL used
+        # to create the table we can look for REFERENCES statements used there.
+        for field_desc in results.split(','):
+            field_desc = field_desc.strip()
+            if field_desc.startswith("UNIQUE"):
+                continue
+
+            m = re.search(r'references (\S*) ?\(["|]?(.*)["|]?\)', field_desc, re.I)
+            if not m:
+                continue
+            table, column = [s.strip('"') for s in m.groups()]
+
+            if field_desc.startswith("FOREIGN KEY"):
+                # Find name of the target FK field
+                m = re.match(r'FOREIGN KEY\s*\(([^\)]*)\).*', field_desc, re.I)
+                field_name = m.groups()[0].strip('"')
+            else:
+                field_name = field_desc.split()[0].strip('"')
+
+            cursor.execute("SELECT sql FROM sqlite_master WHERE tbl_name = %s", [table])
+            result = cursor.fetchall()[0]
+            other_table_results = result[0].strip()
+            li, ri = other_table_results.index('('), other_table_results.rindex(')')
+            other_table_results = other_table_results[li + 1:ri]
+
+            for other_desc in other_table_results.split(','):
+                other_desc = other_desc.strip()
+                if other_desc.startswith('UNIQUE'):
+                    continue
+
+                other_name = other_desc.split(' ', 1)[0].strip('"')
+                if other_name == column:
+                    relations[field_name] = (other_name, table)
+                    break
+
+        return relations
+
+    def get_key_columns(self, cursor, table_name):
+        """
+        Return a list of (column_name, referenced_table_name, referenced_column_name)
+        for all key columns in given table.
+        """
+        key_columns = []
+
+        # Schema for this table
+        cursor.execute("SELECT sql FROM sqlite_master WHERE tbl_name = %s AND type = %s", [table_name, "table"])
+        results = cursor.fetchone()[0].strip()
+        results = results[results.index('(') + 1:results.rindex(')')]
+
+        # Walk through and look for references to other tables. SQLite doesn't
+        # really have enforced references, but since it echoes out the SQL used
+        # to create the table we can look for REFERENCES statements used there.
+        for field_index, field_desc in enumerate(results.split(',')):
+            field_desc = field_desc.strip()
+            if field_desc.startswith("UNIQUE"):
+                continue
+
+            m = re.search(r'"(.*)".*references (.*) \(["|](.*)["|]\)', field_desc, re.I)
+            if not m:
+                continue
+
+            # This will append (column_name, referenced_table_name, referenced_column_name) to key_columns
+            key_columns.append(tuple(s.strip('"') for s in m.groups()))
+
+        return key_columns
+
+    def get_primary_key_column(self, cursor, table_name):
+        """Return the column name of the primary key for the given table."""
+        # Don't use PRAGMA because that causes issues with some transactions
+        cursor.execute(
+            "SELECT sql, type FROM sqlite_master "
+            "WHERE tbl_name = %s AND type IN ('table', 'view')",
+            [table_name]
+        )
+        row = cursor.fetchone()
+        if row is None:
+            raise ValueError("Table %s does not exist" % table_name)
+        create_sql, table_type = row
+        if table_type == 'view':
+            # Views don't have a primary key.
+            return None
+        fields_sql = create_sql[create_sql.index('(') + 1:create_sql.rindex(')')]
+        for field_desc in fields_sql.split(','):
+            field_desc = field_desc.strip()
+            m = re.match(r'(?:(?:["`\[])(.*)(?:["`\]])|(\w+)).*PRIMARY KEY.*', field_desc)
+            if m:
+                return m.group(1) if m.group(1) else m.group(2)
+        return None
+
+    def _table_info(self, cursor, name):
+        cursor.execute('PRAGMA table_info(%s)' % self.connection.ops.quote_name(name))
+        # cid, name, type, notnull, default_value, pk
+        return [{
+            'name': field[1],
+            'type': field[2],
+            'size': get_field_size(field[2]),
+            'null_ok': not field[3],
+            'default': field[4],
+            'pk': field[5],  # undocumented
+        } for field in cursor.fetchall()]
+
+    def _get_foreign_key_constraints(self, cursor, table_name):
+        constraints = {}
+        cursor.execute('PRAGMA foreign_key_list(%s)' % self.connection.ops.quote_name(table_name))
+        for row in cursor.fetchall():
+            # Remaining on_update/on_delete/match values are of no interest.
+            id_, _, table, from_, to = row[:5]
+            constraints['fk_%d' % id_] = {
+                'columns': [from_],
+                'primary_key': False,
+                'unique': False,
+                'foreign_key': (table, to),
+                'check': False,
+                'index': False,
+            }
+        return constraints
+
+    def _parse_column_or_constraint_definition(self, tokens, columns):
+        token = None
+        is_constraint_definition = None
+        field_name = None
+        constraint_name = None
+        unique = False
+        unique_columns = []
+        check = False
+        check_columns = []
+        braces_deep = 0
+        for token in tokens:
+            if token.match(sqlparse.tokens.Punctuation, '('):
+                braces_deep += 1
+            elif token.match(sqlparse.tokens.Punctuation, ')'):
+                braces_deep -= 1
+                if braces_deep < 0:
+                    # End of columns and constraints for table definition.
+                    break
+            elif braces_deep == 0 and token.match(sqlparse.tokens.Punctuation, ','):
+                # End of current column or constraint definition.
+                break
+            # Detect column or constraint definition by first token.
+            if is_constraint_definition is None:
+                is_constraint_definition = token.match(sqlparse.tokens.Keyword, 'CONSTRAINT')
+                if is_constraint_definition:
+                    continue
+            if is_constraint_definition:
+                # Detect constraint name by second token.
+                if constraint_name is None:
+                    if token.ttype in (sqlparse.tokens.Name, sqlparse.tokens.Keyword):
+                        constraint_name = token.value
+                    elif token.ttype == sqlparse.tokens.Literal.String.Symbol:
+                        constraint_name = token.value[1:-1]
+                # Start constraint columns parsing after UNIQUE keyword.
+                if token.match(sqlparse.tokens.Keyword, 'UNIQUE'):
+                    unique = True
+                    unique_braces_deep = braces_deep
+                elif unique:
+                    if unique_braces_deep == braces_deep:
+                        if unique_columns:
+                            # Stop constraint parsing.
+                            unique = False
+                        continue
+                    if token.ttype in (sqlparse.tokens.Name, sqlparse.tokens.Keyword):
+                        unique_columns.append(token.value)
+                    elif token.ttype == sqlparse.tokens.Literal.String.Symbol:
+                        unique_columns.append(token.value[1:-1])
+            else:
+                # Detect field name by first token.
+                if field_name is None:
+                    if token.ttype in (sqlparse.tokens.Name, sqlparse.tokens.Keyword):
+                        field_name = token.value
+                    elif token.ttype == sqlparse.tokens.Literal.String.Symbol:
+                        field_name = token.value[1:-1]
+                if token.match(sqlparse.tokens.Keyword, 'UNIQUE'):
+                    unique_columns = [field_name]
+            # Start constraint columns parsing after CHECK keyword.
+            if token.match(sqlparse.tokens.Keyword, 'CHECK'):
+                check = True
+                check_braces_deep = braces_deep
+            elif check:
+                if check_braces_deep == braces_deep:
+                    if check_columns:
+                        # Stop constraint parsing.
+                        check = False
+                    continue
+                if token.ttype in (sqlparse.tokens.Name, sqlparse.tokens.Keyword):
+                    if token.value in columns:
+                        check_columns.append(token.value)
+                elif token.ttype == sqlparse.tokens.Literal.String.Symbol:
+                    if token.value[1:-1] in columns:
+                        check_columns.append(token.value[1:-1])
+        unique_constraint = {
+            'unique': True,
+            'columns': unique_columns,
+            'primary_key': False,
+            'foreign_key': None,
+            'check': False,
+            'index': False,
+        } if unique_columns else None
+        check_constraint = {
+            'check': True,
+            'columns': check_columns,
+            'primary_key': False,
+            'unique': False,
+            'foreign_key': None,
+            'index': False,
+        } if check_columns else None
+        return constraint_name, unique_constraint, check_constraint, token
+
+    def _parse_table_constraints(self, sql, columns):
+        # Check constraint parsing is based of SQLite syntax diagram.
+        # https://www.sqlite.org/syntaxdiagrams.html#table-constraint
+        statement = sqlparse.parse(sql)[0]
+        constraints = {}
+        unnamed_constrains_index = 0
+        tokens = (token for token in statement.flatten() if not token.is_whitespace)
+        # Go to columns and constraint definition
+        for token in tokens:
+            if token.match(sqlparse.tokens.Punctuation, '('):
+                break
+        # Parse columns and constraint definition
+        while True:
+            constraint_name, unique, check, end_token = self._parse_column_or_constraint_definition(tokens, columns)
+            if unique:
+                if constraint_name:
+                    constraints[constraint_name] = unique
+                else:
+                    unnamed_constrains_index += 1
+                    constraints['__unnamed_constraint_%s__' % unnamed_constrains_index] = unique
+            if check:
+                if constraint_name:
+                    constraints[constraint_name] = check
+                else:
+                    unnamed_constrains_index += 1
+                    constraints['__unnamed_constraint_%s__' % unnamed_constrains_index] = check
+            if end_token.match(sqlparse.tokens.Punctuation, ')'):
+                break
+        return constraints
+
+    def get_constraints(self, cursor, table_name):
+        """
+        Retrieve any constraints or keys (unique, pk, fk, check, index) across
+        one or more columns.
+        """
+        constraints = {}
+        # Find inline check constraints.
+        try:
+            table_schema = cursor.execute(
+                "SELECT sql FROM sqlite_master WHERE type='table' and name=%s" % (
+                    self.connection.ops.quote_name(table_name),
+                )
+            ).fetchone()[0]
+        except TypeError:
+            # table_name is a view.
+            pass
+        else:
+            columns = {info.name for info in self.get_table_description(cursor, table_name)}
+            constraints.update(self._parse_table_constraints(table_schema, columns))
+
+        # Get the index info
+        cursor.execute("PRAGMA index_list(%s)" % self.connection.ops.quote_name(table_name))
+        for row in cursor.fetchall():
+            # SQLite 3.8.9+ has 5 columns, however older versions only give 3
+            # columns. Discard last 2 columns if there.
+            number, index, unique = row[:3]
+            cursor.execute(
+                "SELECT sql FROM sqlite_master "
+                "WHERE type='index' AND name=%s" % self.connection.ops.quote_name(index)
+            )
+            # There's at most one row.
+            sql, = cursor.fetchone() or (None,)
+            # Inline constraints are already detected in
+            # _parse_table_constraints(). The reasons to avoid fetching inline
+            # constraints from `PRAGMA index_list` are:
+            # - Inline constraints can have a different name and information
+            #   than what `PRAGMA index_list` gives.
+            # - Not all inline constraints may appear in `PRAGMA index_list`.
+            if not sql:
+                # An inline constraint
+                continue
+            # Get the index info for that index
+            cursor.execute('PRAGMA index_info(%s)' % self.connection.ops.quote_name(index))
+            for index_rank, column_rank, column in cursor.fetchall():
+                if index not in constraints:
+                    constraints[index] = {
+                        "columns": [],
+                        "primary_key": False,
+                        "unique": bool(unique),
+                        "foreign_key": None,
+                        "check": False,
+                        "index": True,
+                    }
+                constraints[index]['columns'].append(column)
+            # Add type and column orders for indexes
+            if constraints[index]['index'] and not constraints[index]['unique']:
+                # SQLite doesn't support any index type other than b-tree
+                constraints[index]['type'] = Index.suffix
+                order_info = sql.split('(')[-1].split(')')[0].split(',')
+                orders = ['DESC' if info.endswith('DESC') else 'ASC' for info in order_info]
+                constraints[index]['orders'] = orders
+        # Get the PK
+        pk_column = self.get_primary_key_column(cursor, table_name)
+        if pk_column:
+            # SQLite doesn't actually give a name to the PK constraint,
+            # so we invent one. This is fine, as the SQLite backend never
+            # deletes PK constraints by name, as you can't delete constraints
+            # in SQLite; we remake the table with a new PK instead.
+            constraints["__primary__"] = {
+                "columns": [pk_column],
+                "primary_key": True,
+                "unique": False,  # It's not actually a unique constraint.
+                "foreign_key": None,
+                "check": False,
+                "index": False,
+            }
+        constraints.update(self._get_foreign_key_constraints(cursor, table_name))
+        return constraints