darker and mypy

edb/pgsql/compiler/__init__.py

@@ -64,10 +64,7 @@ def compile_ir_to_sql_tree(
         Mapping[Tuple[irast.PathId, str], pgast.PathRangeVar]
     ] = None,
     external_rels: Optional[
-        Mapping[
-            irast.PathId,
-            Tuple[pgast.BaseRelation | pgast.CommonTableExpr, Tuple[str, ...]],
-        ]
+        Mapping[irast.PathId, context.ExternalRelsEntry]
     ] = None,
     backend_runtime_params: Optional[pgparams.BackendRuntimeParams]=None,
 ) -> CompileResult:

edb/pgsql/compiler/context.py

@@ -184,6 +184,17 @@ class RelOverlays:
     def copy(self) -> RelOverlays:
         return RelOverlays(type=self.type, ptr=self.ptr)
 
+if TYPE_CHECKING:
+    # external rels entries map to:
+    # - the rel that represents that path id,
+    # - aspects provided by the rel,
+    # - additional path ids and aspects provided
+    ExternalRelsEntry = Tuple[
+        pgast.BaseRelation | pgast.CommonTableExpr,
+        Tuple[str, ...],
+        Tuple[Tuple[irast.PathId, Tuple[str, ...]], ...],
+    ]
+
 
 class CompilerContextLevel(compiler.ContextLevel):
     #: static compilation environment
@@ -290,14 +301,7 @@ class CompilerContextLevel(compiler.ContextLevel):
     rel_overlays: RelOverlays
 
     #: Mapping from path ids to "external" rels given by a particular relation
-    external_rels: Mapping[
-        irast.PathId,
-        Tuple[
-            pgast.BaseRelation | pgast.CommonTableExpr,
-            Tuple[str, ...],
-            Tuple[Tuple[irast.PathId, Tuple[str, ...]], ...]
-        ]
-    ]
+    external_rels: Mapping[irast.PathId, ExternalRelsEntry]
 
     #: The CTE and some metadata of any enclosing iterator-like
     #: construct (which includes iterators, insert/update, and INSERT

edb/pgsql/compiler/dml.py

@@ -3229,12 +3229,21 @@ def compile_trigger(
             tctx.external_rels = dict(tctx.external_rels)
             # new_path is just the contents_cte
             tctx.external_rels[new_path] = (
-                contents_cte, ('value', 'source'), ())
+                contents_cte,
+                ('value', 'source'),
+                (),
+            )
             if old_path:
                 # old_path is *also* the contents_cte, but without a source
                 # aspect, so we need to include the real database back in.
                 tctx.external_rels[old_path] = (
-                    contents_cte, ('value', 'identity',), ())
+                    contents_cte,
+                    (
+                        'value',
+                        'identity',
+                    ),
+                    (),
+                )
 
         # This is somewhat subtle: we merge *every* DML into
         # the "None" overlay, so that all the new database state shows

edb/pgsql/compiler/relgen.py

@@ -875,6 +875,7 @@ def process_set_as_link_property_ref(
                 newctx.rel, link_path_id, aspect='source', ctx=newctx
             )
         if link_rvar is None:
+            assert link_prefix.rptr is not None
             link_rvar = relctx.new_pointer_rvar(
                 link_prefix.rptr, src_rvar=src_rvar,
                 link_bias=True, ctx=newctx)

edb/pgsql/delta.py

@@ -4882,7 +4882,7 @@ def _compile_conversion_expr(
         )
         src_rel.path_outputs[(src_path_id, 'iterator')] = \
             pgast.ColumnRef(name=('id',))
-        external_rels = {
+        ext_rels: Dict[irast.PathId, compiler.context.ExternalRelsEntry] = {
             src_path_id: (src_rel, ('source', 'identity', 'iterator'), ())
         }
 
@@ -4898,14 +4898,19 @@ def _compile_conversion_expr(
                 src_rel.path_outputs[(tgt_path_id, 'iterator')] = \
                     pgast.ColumnRef(name=('id',))
 
-            external_rels[ptr_path_id] = \
-                (src_rel, ('source'), ())
+            ext_rels[ptr_path_id] = (src_rel, ('source',), ())
             if ptr_table:
-                external_rels[tgt_path_id] = \
-                    (src_rel, ('identity', 'source', 'value', 'iterator'), ((ptr_path_id, ('source', 'identity')),))
+                ext_rels[tgt_path_id] = (
+                    src_rel,
+                    ('identity', 'source', 'value', 'iterator'),
+                    ((ptr_path_id, ('source', 'identity')),),
+                )
             else:
-                external_rels[tgt_path_id] = \
-                    (src_rel, ('identity', 'value', 'iterator'), ())
+                ext_rels[tgt_path_id] = (
+                    src_rel,
+                    ('identity', 'value', 'iterator'),
+                    (),
+                )
 
         # Wrap the expression into a select with iterator, so DML and
         # volatile expressions are executed once for each object.
@@ -4979,7 +4984,7 @@ def _compile_conversion_expr(
         sql_res = compiler.compile_ir_to_sql_tree(
             ir,
             output_format=compiler.OutputFormat.NATIVE_INTERNAL,
-            external_rels=external_rels,
+            external_rels=ext_rels,
             backend_runtime_params=context.backend_runtime_params,
         )
         sql_tree = sql_res.ast

tests/test_edgeql_ddl.py

@@ -3038,10 +3038,7 @@ async def test_edgeql_ddl_ptr_using_dml_03(self):
 
         # only one Goodbye object, as only one link exists, so only one cast is
         # performed
-        await self.assert_query_result(
-            'select Goodbye',
-            [{}]
-        )
+        await self.assert_query_result('select Goodbye', [{}])
         await self.assert_query_result(
             'select World { hell }',
             tb.bag([{'hell': None}, {'hell': {'id': uuid.UUID}}])
@@ -3084,8 +3081,7 @@ async def test_edgeql_ddl_ptr_using_dml_05(self):
             """
         )
         await self.assert_query_result(
-            'SELECT World { foo }',
-            [{"foo": "hello"}]
+            'SELECT World { foo }', [{"foo": "hello"}]
         )
 
         await self.con.execute(