Only wrap PostgreSQL temp tables in transactions.

Making SQLite temp tables inside transactions leads to very long
exclusive locks during QG generation, causing timeouts in (at least)
ci_cpp.

python/lsst/daf/butler/registry/databases/postgresql.py

@@ -160,6 +160,15 @@ def transaction(
                         cursor.execute("SET TIME ZONE 0")
             yield is_new
 
+    @contextmanager
+    def temporary_table(
+        self, spec: ddl.TableSpec, name: Optional[str] = None
+    ) -> Iterator[sqlalchemy.schema.Table]:
+        # Docstring inherited.
+        with self.transaction(for_temp_tables=True):
+            with super().temporary_table(spec, name) as table:
+                yield table
+
     def _lockTables(
         self, connection: sqlalchemy.engine.Connection, tables: Iterable[sqlalchemy.schema.Table] = ()
     ) -> None:

python/lsst/daf/butler/registry/interfaces/_database.py

@@ -468,13 +468,14 @@ def temporary_table(
         otherwise, but in that case they probably need to be modified to
         support the full range of expected read-only butler behavior.
         """
-        with self._transaction_connection(for_temp_tables=True) as connection:
-            table = self._make_temporary_table(connection, spec=spec, name=name)
+        with self.session():
+            assert self._session_connection is not None, "Guaranteed by session()."
+            table = self._make_temporary_table(self._session_connection, spec=spec, name=name)
             self._temp_tables.add(table.key)
             try:
                 yield table
             finally:
-                table.drop(connection)
+                table.drop(self._session_connection)
                 self._temp_tables.remove(table.key)
 
     @contextmanager