Ticket #17213: 17213.diff

django/db/backends/postgresql_psycopg2/base.py

@@ -109 +109 @@
         self.introspection = DatabaseIntrospection(self)
         self.validation = BaseDatabaseValidation(self)
         self._pg_version = None
+        self.force_db_set = True
 
     def check_constraints(self, table_names=None):
         """
@@ -143 +144 @@
     pg_version = property(_get_pg_version)
 
     def _cursor(self):
-        new_connection = False
+        force_db_set = self.force_db_set or self.connection is None
         set_tz = False
         settings_dict = self.settings_dict
-        if self.connection is None:
-            new_connection = True
+        if force_db_set:
             set_tz = settings_dict.get('TIME_ZONE')
             if settings_dict['NAME'] == '':
                 from django.core.exceptions import ImproperlyConfigured
@@ -172 +172 @@
             connection_created.send(sender=self.__class__, connection=self)
         cursor = self.connection.cursor()
         cursor.tzinfo_factory = None
-        if new_connection:
+        if force_db_set:
             if set_tz:
-                cursor.execute("SET TIME ZONE %s", [settings_dict['TIME_ZONE']])
+                self._set_tz(cursor, settings_dict['TIME_ZONE'])
             self._get_pg_version()
+            self.force_db_set = False
         return CursorWrapper(cursor)
 
+    def _set_tz(self, cursor, tz):
+        cursor.execute("SET TIME ZONE %s", [tz])
+
     def _enter_transaction_management(self, managed):
         """
         Switch the isolation level when needing transaction support, so that

tests/regressiontests/backends/tests.py

@@ -308 +308 @@
         self.assertTrue(hasattr(connection.ops, 'connection'))
         self.assertEqual(connection, connection.ops.connection)
 
+    @unittest.skipUnless(connection.vendor == 'postgresql',
+                         "SET TIME ZIME needs executed again if TIME_ZONE changes")
+    def test_cursor_force_db_set(self):
+        _set_tz = connection._set_tz
+        def mock_set_tz(*args, **kwargs):
+            mock_set_tz.called = (args, kwargs)
+        mock_set_tz.called = False
+        connection._set_tz = mock_set_tz
+        try:
+            connection.cursor()
+            self.assert_(mock_set_tz.called)
+            self.assertEqual(settings.TIME_ZONE, mock_set_tz.called[0][1])
+            mock_set_tz.called = False
+
+            connection.cursor()
+            self.assertFalse(mock_set_tz.called)
+            mock_set_tz.called = False
+
+            connection.force_db_set = True
+            connection.cursor()
+            self.assert_(mock_set_tz.called)
+            self.assertEqual(settings.TIME_ZONE, mock_set_tz.called[0][1])
+            mock_set_tz.called = False
+
+        finally:
+            connection._set_tz = _set_tz
+
 
 # We don't make these tests conditional because that means we would need to
 # check and differentiate between:

tests/regressiontests/model_regress/tests.py

@@ -148 +148 @@
 
     @skipUnlessDBFeature("supports_timezones")
     def test_timezones(self):
-        # Saving an updating with timezone-aware datetime Python objects.
+        # Saving and updating with timezone-aware datetime Python objects.
         # Regression test for #10443.
         # The idea is that all these creations and saving should work without
         # crashing. It's not rocket science.