Use CTE instead of inheritance views when generating ranges for types

edb/common/debug.py

@@ -116,9 +116,6 @@ class flags(metaclass=FlagsMeta):
     edgeql_disable_normalization = Flag(
         doc="Disable EdgeQL normalization (constant extraction etc)")
 
-    edgeql_expand_inhviews = Flag(
-        doc="Force the EdgeQL compiler to expand inhviews *always*")
-
     graphql_compile = Flag(
         doc="Debug GraphQL compiler.")
 

edb/edgeql/compiler/options.py

@@ -77,10 +77,10 @@ class GlobalCompilerOptions:
     #: definitions.
     func_params: Optional[s_func.ParameterLikeList] = None
 
-    #: Should the backend compiler expand out inheritance views instead of
-    #: using them. This is needed by EXPLAIN to maintain alias names in
+    #: Should the backend compiler expand inheritance CTEs in place.
+    #: This is needed by EXPLAIN to maintain alias names in
     #: the query plan.
-    expand_inhviews: bool = False
+    is_explain: bool = False
 
     #: The name that can be used in a "DML is disallowed in ..."
     #: error. When this is not None, any DML should cause an error.

edb/edgeql/compiler/typegen.py

@@ -401,10 +401,7 @@ def type_to_typeref(
     include_children = (
         expr_type is s_types.ExprType.Update
         or expr_type is s_types.ExprType.Delete
-        or (
-            env.options.expand_inhviews
-            and isinstance(t, s_objtypes.ObjectType)
-        )
+        or isinstance(t, s_objtypes.ObjectType)
     )
     include_ancestors = (
         expr_type is s_types.ExprType.Insert

edb/ir/ast.py

@@ -173,6 +173,8 @@ class TypeRef(ImmutableBase):
     is_scalar: bool = False
     # True, if this describes a view
     is_view: bool = False
+    # True, if this describes a cfg view
+    is_cfg_view: bool = False
     # True, if this describes an abstract type
     is_abstract: bool = False
     # True, if the collection type is persisted in the schema

edb/ir/pathid.py

@@ -257,8 +257,6 @@ def from_typeref(
         which case it is used instead.
 
         Args:
-            schema:
-                A schema instance where the type *t* is defined.
             typeref:
                 The descriptor of a type of the variable being defined.
             namespace:
@@ -278,6 +276,28 @@ def from_typeref(
         pid._namespace = frozenset(namespace)
         return pid
 
+    @classmethod
+    def from_ptrref(
+        cls,
+        ptrref: irast.PointerRef,
+        *,
+        namespace: AbstractSet[Namespace] = frozenset(),
+    ) -> PathId:
+        """Return a ``PathId`` instance for a given :class:`ir.ast.PointerRef`
+
+        Args:
+            ptrref:
+                The descriptor of a ptr of the variable being defined.
+            namespace:
+                Optional namespace in which the variable is defined.
+
+        Returns:
+            A ``PathId`` instance of type described by *ptrref*.
+        """
+        pid = cls.from_typeref(ptrref.out_source, namespace=namespace)
+        pid = pid.extend(ptrref=ptrref)
+        return pid
+
     @classmethod
     def new_dummy(cls, name: str) -> PathId:
         name_hint = s_name.QualName(module='__derived__', name=name)

edb/ir/typeutils.py

@@ -61,6 +61,36 @@
 TypeRefCache = dict[TypeRefCacheKey, 'irast.TypeRef']
 
 
+# Modules where all the "types" in them are really just custom views
+# provided by metaschema.
+VIEW_MODULES = ('sys', 'cfg')
+
+
+def is_cfg_view(
+    obj: s_obj.Object,
+    schema: s_schema.Schema,
+) -> bool:
+    return (
+        isinstance(obj, (s_objtypes.ObjectType, s_pointers.Pointer))
+        and (
+            obj.get_name(schema).module in VIEW_MODULES
+            or bool(
+                (cfg_object := schema.get(
+                    'cfg::ConfigObject',
+                    type=s_objtypes.ObjectType, default=None
+                ))
+                and (
+                    nobj := (
+                        obj if isinstance(obj, s_objtypes.ObjectType)
+                        else obj.get_source(schema)
+                    )
+                )
+                and nobj.issubclass(schema, cfg_object)
+            )
+        )
+    )
+
+
 def is_scalar(typeref: irast.TypeRef) -> bool:
     """Return True if *typeref* describes a scalar type."""
     return typeref.is_scalar
@@ -400,6 +430,7 @@ def _typeref(
             is_scalar=t.is_scalar(),
             is_abstract=t.get_abstract(schema),
             is_view=t.is_view(schema),
+            is_cfg_view=is_cfg_view(t, schema),
             is_opaque_union=t.get_is_opaque_union(schema),
             needs_custom_json_cast=needs_custom_json_cast,
             sql_type=sql_type,

edb/pgsql/compiler/__init__.py

@@ -66,7 +66,7 @@ def compile_ir_to_sql_tree(
     singleton_mode: bool = False,
     named_param_prefix: Optional[tuple[str, ...]] = None,
     expected_cardinality_one: bool = False,
-    expand_inhviews: bool = False,
+    is_explain: bool = False,
     external_rvars: Optional[
         Mapping[Tuple[irast.PathId, pgce.PathAspect], pgast.PathRangeVar]
     ] = None,
@@ -127,7 +127,7 @@ def compile_ir_to_sql_tree(
             type_rewrites=type_rewrites,
             ignore_object_shapes=ignore_shapes,
             explicit_top_cast=explicit_top_cast,
-            expand_inhviews=expand_inhviews,
+            is_explain=is_explain,
             singleton_mode=singleton_mode,
             scope_tree_nodes=scope_tree_nodes,
             external_rvars=external_rvars,
@@ -156,9 +156,15 @@ def compile_ir_to_sql_tree(
         qtree = dispatch.compile(ir_expr, ctx=ctx)
         dml.compile_triggers(triggers, qtree, ctx=ctx)
 
-        if isinstance(ir_expr, irast.Set) and not singleton_mode:
-            assert isinstance(qtree, pgast.Query)
-            clauses.fini_toplevel(qtree, ctx)
+        if not singleton_mode:
+            if isinstance(ir_expr, irast.Set):
+                assert isinstance(qtree, pgast.Query)
+                clauses.fini_toplevel(qtree, ctx)
+
+            elif isinstance(qtree, pgast.Query):
+                # Other types of expressions may compile to queries which may
+                # use inheritance CTEs. Ensure they are added here.
+                clauses.insert_ctes(qtree, ctx)
 
         if detach_params:
             detached_params_idx = {

edb/pgsql/compiler/clauses.py

@@ -409,20 +409,26 @@ def scan_check_ctes(
     ))
 
 
-def fini_toplevel(
-        stmt: pgast.Query, ctx: context.CompilerContextLevel) -> None:
-
-    scan_check_ctes(stmt, ctx.env.check_ctes, ctx=ctx)
-
-    # Type rewrites go first.
+def insert_ctes(
+    stmt: pgast.Query, ctx: context.CompilerContextLevel
+) -> None:
     if stmt.ctes is None:
         stmt.ctes = []
     stmt.ctes[:0] = [
         *ctx.param_ctes.values(),
-        *ctx.ptr_ctes.values(),
-        *ctx.type_ctes.values(),
+        *ctx.ptr_inheritance_ctes.values(),
+        *ctx.ordered_type_ctes,
     ]
 
+
+def fini_toplevel(
+        stmt: pgast.Query, ctx: context.CompilerContextLevel) -> None:
+
+    scan_check_ctes(stmt, ctx.env.check_ctes, ctx=ctx)
+
+    # Type rewrites and inheritance CTEs go first.
+    insert_ctes(stmt, ctx)
+
     if ctx.env.named_param_prefix is None:
         # Adding unused parameters into a CTE
 

edb/pgsql/compiler/context.py

@@ -242,15 +242,21 @@ class CompilerContextLevel(compiler.ContextLevel):
     #: CTEs representing decoded parameters
     param_ctes: Dict[str, pgast.CommonTableExpr]
 
-    #: CTEs representing pointer tables that we need to force to be
-    #: materialized for performance reasons.
-    ptr_ctes: Dict[uuid.UUID, pgast.CommonTableExpr]
+    #: CTEs representing pointers and their inherited pointers
+    ptr_inheritance_ctes: Dict[uuid.UUID, pgast.CommonTableExpr]
 
     #: CTEs representing types, when rewritten based on access policy
-    type_ctes: Dict[FullRewriteKey, pgast.CommonTableExpr]
+    type_rewrite_ctes: Dict[FullRewriteKey, pgast.CommonTableExpr]
 
     #: A set of type CTEs currently being generated
-    pending_type_ctes: Set[RewriteKey]
+    pending_type_rewrite_ctes: Set[RewriteKey]
+
+    #: CTEs representing types and their inherited types
+    type_inheritance_ctes: Dict[uuid.UUID, pgast.CommonTableExpr]
+
+    # Type and type inheriance CTEs in creation order. This ensures type CTEs
+    # referring to other CTEs are in the correct order.
+    ordered_type_ctes: list[pgast.CommonTableExpr]
 
     #: The logical parent of the current query in the
     #: query hierarchy
@@ -351,9 +357,11 @@ def __init__(
             self.rel = NO_STMT
             self.rel_hierarchy = {}
             self.param_ctes = {}
-            self.ptr_ctes = {}
-            self.type_ctes = {}
-            self.pending_type_ctes = set()
+            self.ptr_inheritance_ctes = {}
+            self.type_rewrite_ctes = {}
+            self.pending_type_rewrite_ctes = set()
+            self.type_inheritance_ctes = {}
+            self.ordered_type_ctes = []
             self.dml_stmts = {}
             self.parent_rel = None
             self.pending_query = None
@@ -391,9 +399,11 @@ def __init__(
             self.rel = prevlevel.rel
             self.rel_hierarchy = prevlevel.rel_hierarchy
             self.param_ctes = prevlevel.param_ctes
-            self.ptr_ctes = prevlevel.ptr_ctes
-            self.type_ctes = prevlevel.type_ctes
-            self.pending_type_ctes = prevlevel.pending_type_ctes
+            self.ptr_inheritance_ctes = prevlevel.ptr_inheritance_ctes
+            self.type_rewrite_ctes = prevlevel.type_rewrite_ctes
+            self.pending_type_rewrite_ctes = prevlevel.pending_type_rewrite_ctes
+            self.type_inheritance_ctes = prevlevel.type_inheritance_ctes
+            self.ordered_type_ctes = prevlevel.ordered_type_ctes
             self.dml_stmts = prevlevel.dml_stmts
             self.parent_rel = prevlevel.parent_rel
             self.pending_query = prevlevel.pending_query
@@ -456,7 +466,9 @@ def __init__(
                 self.disable_semi_join = frozenset()
                 self.force_optional = frozenset()
                 self.intersection_narrowing = {}
-                self.pending_type_ctes = set(prevlevel.pending_type_ctes)
+                self.pending_type_rewrite_ctes = set(
+                    prevlevel.pending_type_rewrite_ctes
+                )
 
             elif mode == ContextSwitchMode.NEWSCOPE:
                 self.path_scope = prevlevel.path_scope.new_child()
@@ -536,7 +548,7 @@ def __init__(
         expected_cardinality_one: bool,
         ignore_object_shapes: bool,
         singleton_mode: bool,
-        expand_inhviews: bool,
+        is_explain: bool,
         explicit_top_cast: Optional[irast.TypeRef],
         query_params: List[irast.Param],
         type_rewrites: Dict[RewriteKey, irast.Set],
@@ -555,7 +567,7 @@ def __init__(
         self.expected_cardinality_one = expected_cardinality_one
         self.ignore_object_shapes = ignore_object_shapes
         self.singleton_mode = singleton_mode
-        self.expand_inhviews = expand_inhviews
+        self.is_explain = is_explain
         self.explicit_top_cast = explicit_top_cast
         self.query_params = query_params
         self.type_rewrites = type_rewrites

edb/pgsql/compiler/dml.py

@@ -3139,7 +3139,9 @@ def compile_triggers(
         # FIXME: I think we actually need to keep the old type_ctes
         # available for pointers off of __old__ to use.
         ictx.trigger_mode = True
-        ictx.type_ctes = {}
+        ictx.type_rewrite_ctes = {}
+        ictx.type_inheritance_ctes = {}
+        ictx.ordered_type_ctes = []
         ictx.toplevel_stmt = stmt
 
         for stage in triggers:
@@ -3156,7 +3158,7 @@ def compile_triggers(
 
     # Install any newly created type CTEs before the CTEs created from
     # this trigger compilation but after anything compiled before.
-    stmt.ctes[start_ctes:start_ctes] = list(ictx.type_ctes.values())
+    stmt.ctes[start_ctes:start_ctes] = ictx.ordered_type_ctes
 
 
 def compile_trigger(