Explicitly close cursors

django/contrib/gis/db/backends/postgis/creation.py

@@ -11,10 +11,10 @@ class PostGISCreation(DatabaseCreation):
     @cached_property
     def template_postgis(self):
         template_postgis = getattr(settings, 'POSTGIS_TEMPLATE', 'template_postgis')
-        cursor = self.connection.cursor()
-        cursor.execute('SELECT 1 FROM pg_database WHERE datname = %s LIMIT 1;', (template_postgis,))
-        if cursor.fetchone():
-            return template_postgis
+        with self.connection.cursor() as cursor:
+            cursor.execute('SELECT 1 FROM pg_database WHERE datname = %s LIMIT 1;', (template_postgis,))
+            if cursor.fetchone():
+                return template_postgis
         return None
 
     def sql_indexes_for_field(self, model, f, style):
@@ -88,8 +88,8 @@ def _create_test_db(self, verbosity, autoclobber):
             # Connect to the test database in order to create the postgis extension
             self.connection.close()
             self.connection.settings_dict["NAME"] = test_database_name
-            cursor = self.connection.cursor()
-            cursor.execute("CREATE EXTENSION IF NOT EXISTS postgis")
-            cursor.connection.commit()
+            with self.connection.cursor() as cursor:
+                cursor.execute("CREATE EXTENSION IF NOT EXISTS postgis")
+                cursor.connection.commit()
 
         return test_database_name

django/contrib/gis/db/backends/spatialite/creation.py

@@ -55,9 +55,8 @@ def create_test_db(self, verbosity=1, autoclobber=False):
 
         call_command('createcachetable', database=self.connection.alias)
 
-        # Get a cursor (even though we don't need one yet). This has
-        # the side effect of initializing the test database.
-        self.connection.cursor()
+        # Ensure a connection for the side effect of initializing the test database.
+        self.connection.ensure_connection()
 
         return test_database_name
 

django/contrib/sites/management.py

@@ -33,9 +33,9 @@ def create_default_site(app_config, verbosity=2, interactive=True, db=DEFAULT_DB
         if sequence_sql:
             if verbosity >= 2:
                 print("Resetting sequence")
-            cursor = connections[db].cursor()
-            for command in sequence_sql:
-                cursor.execute(command)
+            with connections[db].cursor() as cursor:
+                for command in sequence_sql:
+                    cursor.execute(command)
 
         Site.objects.clear_cache()
 

django/core/cache/backends/db.py

@@ -59,11 +59,11 @@ def get(self, key, default=None, version=None):
         self.validate_key(key)
         db = router.db_for_read(self.cache_model_class)
         table = connections[db].ops.quote_name(self._table)
-        cursor = connections[db].cursor()
 
-        cursor.execute("SELECT cache_key, value, expires FROM %s "
-                       "WHERE cache_key = %%s" % table, [key])
-        row = cursor.fetchone()
+        with connections[db].cursor() as cursor:
+            cursor.execute("SELECT cache_key, value, expires FROM %s "
+                           "WHERE cache_key = %%s" % table, [key])
+            row = cursor.fetchone()
         if row is None:
             return default
         now = timezone.now()
@@ -75,9 +75,9 @@ def get(self, key, default=None, version=None):
             expires = typecast_timestamp(str(expires))
         if expires < now:
             db = router.db_for_write(self.cache_model_class)
-            cursor = connections[db].cursor()
-            cursor.execute("DELETE FROM %s "
-                           "WHERE cache_key = %%s" % table, [key])
+            with connections[db].cursor() as cursor:
+                cursor.execute("DELETE FROM %s "
+                               "WHERE cache_key = %%s" % table, [key])
             return default
         value = connections[db].ops.process_clob(row[1])
         return pickle.loads(base64.b64decode(force_bytes(value)))
@@ -96,83 +96,84 @@ def _base_set(self, mode, key, value, timeout=DEFAULT_TIMEOUT):
         timeout = self.get_backend_timeout(timeout)
         db = router.db_for_write(self.cache_model_class)
         table = connections[db].ops.quote_name(self._table)
-        cursor = connections[db].cursor()
 
-        cursor.execute("SELECT COUNT(*) FROM %s" % table)
-        num = cursor.fetchone()[0]
-        now = timezone.now()
-        now = now.replace(microsecond=0)
-        if timeout is None:
-            exp = datetime.max
-        elif settings.USE_TZ:
-            exp = datetime.utcfromtimestamp(timeout)
-        else:
-            exp = datetime.fromtimestamp(timeout)
-        exp = exp.replace(microsecond=0)
-        if num > self._max_entries:
-            self._cull(db, cursor, now)
-        pickled = pickle.dumps(value, pickle.HIGHEST_PROTOCOL)
-        b64encoded = base64.b64encode(pickled)
-        # The DB column is expecting a string, so make sure the value is a
-        # string, not bytes. Refs #19274.
-        if six.PY3:
-            b64encoded = b64encoded.decode('latin1')
-        try:
-            # Note: typecasting for datetimes is needed by some 3rd party
-            # database backends. All core backends work without typecasting,
-            # so be careful about changes here - test suite will NOT pick
-            # regressions.
-            with transaction.atomic(using=db):
-                cursor.execute("SELECT cache_key, expires FROM %s "
-                               "WHERE cache_key = %%s" % table, [key])
-                result = cursor.fetchone()
-                if result:
-                    current_expires = result[1]
-                    if (connections[db].features.needs_datetime_string_cast and not
-                            isinstance(current_expires, datetime)):
-                        current_expires = typecast_timestamp(str(current_expires))
-                exp = connections[db].ops.value_to_db_datetime(exp)
-                if result and (mode == 'set' or (mode == 'add' and current_expires < now)):
-                    cursor.execute("UPDATE %s SET value = %%s, expires = %%s "
-                                   "WHERE cache_key = %%s" % table,
-                                   [b64encoded, exp, key])
-                else:
-                    cursor.execute("INSERT INTO %s (cache_key, value, expires) "
-                                   "VALUES (%%s, %%s, %%s)" % table,
-                                   [key, b64encoded, exp])
-        except DatabaseError:
-            # To be threadsafe, updates/inserts are allowed to fail silently
-            return False
-        else:
-            return True
+        with connections[db].cursor() as cursor:
+            cursor.execute("SELECT COUNT(*) FROM %s" % table)
+            num = cursor.fetchone()[0]
+            now = timezone.now()
+            now = now.replace(microsecond=0)
+            if timeout is None:
+                exp = datetime.max
+            elif settings.USE_TZ:
+                exp = datetime.utcfromtimestamp(timeout)
+            else:
+                exp = datetime.fromtimestamp(timeout)
+            exp = exp.replace(microsecond=0)
+            if num > self._max_entries:
+                self._cull(db, cursor, now)
+            pickled = pickle.dumps(value, pickle.HIGHEST_PROTOCOL)
+            b64encoded = base64.b64encode(pickled)
+            # The DB column is expecting a string, so make sure the value is a
+            # string, not bytes. Refs #19274.
+            if six.PY3:
+                b64encoded = b64encoded.decode('latin1')
+            try:
+                # Note: typecasting for datetimes is needed by some 3rd party
+                # database backends. All core backends work without typecasting,
+                # so be careful about changes here - test suite will NOT pick
+                # regressions.
+                with transaction.atomic(using=db):
+                    cursor.execute("SELECT cache_key, expires FROM %s "
+                                   "WHERE cache_key = %%s" % table, [key])
+                    result = cursor.fetchone()
+                    if result:
+                        current_expires = result[1]
+                        if (connections[db].features.needs_datetime_string_cast and not
+                                isinstance(current_expires, datetime)):
+                            current_expires = typecast_timestamp(str(current_expires))
+                    exp = connections[db].ops.value_to_db_datetime(exp)
+                    if result and (mode == 'set' or (mode == 'add' and current_expires < now)):
+                        cursor.execute("UPDATE %s SET value = %%s, expires = %%s "
+                                       "WHERE cache_key = %%s" % table,
+                                       [b64encoded, exp, key])
+                    else:
+                        cursor.execute("INSERT INTO %s (cache_key, value, expires) "
+                                       "VALUES (%%s, %%s, %%s)" % table,
+                                       [key, b64encoded, exp])
+            except DatabaseError:
+                # To be threadsafe, updates/inserts are allowed to fail silently
+                return False
+            else:
+                return True
 
     def delete(self, key, version=None):
         key = self.make_key(key, version=version)
         self.validate_key(key)
 
         db = router.db_for_write(self.cache_model_class)
         table = connections[db].ops.quote_name(self._table)
-        cursor = connections[db].cursor()
 
-        cursor.execute("DELETE FROM %s WHERE cache_key = %%s" % table, [key])
+        with connections[db].cursor() as cursor:
+            cursor.execute("DELETE FROM %s WHERE cache_key = %%s" % table, [key])
 
     def has_key(self, key, version=None):
         key = self.make_key(key, version=version)
         self.validate_key(key)
 
         db = router.db_for_read(self.cache_model_class)
         table = connections[db].ops.quote_name(self._table)
-        cursor = connections[db].cursor()
 
         if settings.USE_TZ:
             now = datetime.utcnow()
         else:
             now = datetime.now()
         now = now.replace(microsecond=0)
-        cursor.execute("SELECT cache_key FROM %s "
-                       "WHERE cache_key = %%s and expires > %%s" % table,
-                       [key, connections[db].ops.value_to_db_datetime(now)])
-        return cursor.fetchone() is not None
+
+        with connections[db].cursor() as cursor:
+            cursor.execute("SELECT cache_key FROM %s "
+                           "WHERE cache_key = %%s and expires > %%s" % table,
+                           [key, connections[db].ops.value_to_db_datetime(now)])
+            return cursor.fetchone() is not None
 
     def _cull(self, db, cursor, now):
         if self._cull_frequency == 0:
@@ -197,8 +198,8 @@ def _cull(self, db, cursor, now):
     def clear(self):
         db = router.db_for_write(self.cache_model_class)
         table = connections[db].ops.quote_name(self._table)
-        cursor = connections[db].cursor()
-        cursor.execute('DELETE FROM %s' % table)
+        with connections[db].cursor() as cursor:
+            cursor.execute('DELETE FROM %s' % table)
 
 
 # For backwards compatibility

django/core/management/commands/createcachetable.py

@@ -72,14 +72,14 @@ def create_table(self, database, tablename):
             full_statement.append('    %s%s' % (line, ',' if i < len(table_output) - 1 else ''))
         full_statement.append(');')
         with transaction.commit_on_success_unless_managed():
-            curs = connection.cursor()
-            try:
-                curs.execute("\n".join(full_statement))
-            except DatabaseError as e:
-                raise CommandError(
-                    "Cache table '%s' could not be created.\nThe error was: %s." %
-                    (tablename, force_text(e)))
-            for statement in index_output:
-                curs.execute(statement)
+            with connection.cursor() as curs:
+                try:
+                    curs.execute("\n".join(full_statement))
+                except DatabaseError as e:
+                    raise CommandError(
+                        "Cache table '%s' could not be created.\nThe error was: %s." %
+                        (tablename, force_text(e)))
+                for statement in index_output:
+                    curs.execute(statement)
         if self.verbosity > 1:
             self.stdout.write("Cache table '%s' created." % tablename)

django/core/management/commands/flush.py

@@ -64,9 +64,9 @@ def handle_noargs(self, **options):
         if confirm == 'yes':
             try:
                 with transaction.commit_on_success_unless_managed():
-                    cursor = connection.cursor()
-                    for sql in sql_list:
-                        cursor.execute(sql)
+                    with connection.cursor() as cursor:
+                        for sql in sql_list:
+                            cursor.execute(sql)
             except Exception as e:
                 new_msg = (
                     "Database %s couldn't be flushed. Possible reasons:\n"