def get_ancestors(
fq_name: s_name.QualName,
ancestors: Dict[s_name.QualName, Set[s_name.QualName]],
parents: Mapping[s_name.QualName, AbstractSet[s_name.QualName]],
) -> Set[s_name.QualName]:
"""Recursively compute ancestors (in place) from the parents graph."""
# value already computed
result = ancestors.get(fq_name, set())
if result is RECURSION_GUARD:
raise errors.InvalidDefinitionError(
f'{str(fq_name)!r} is defined recursively')
elif result:
return result
ancestors[fq_name] = RECURSION_GUARD
parent_set = parents.get(fq_name, set())
# base case: include the parents
result = set(parent_set)
for fq_parent in parent_set:
# recursive step: include parents' ancestors
result |= get_ancestors(fq_parent, ancestors, parents)
ancestors[fq_name] = result
return result
def _alter_begin(
self,
schema: s_schema.Schema,
context: sd.CommandContext,
) -> s_schema.Schema:
orig_schema = schema
schema = super()._alter_begin(schema, context)
scls = self.scls
orig_owned = scls.get_is_owned(orig_schema)
owned = scls.get_is_owned(schema)
if (orig_owned != owned and not owned and not context.canonical):
implicit_bases = scls.get_implicit_bases(schema)
if not implicit_bases:
# ref isn't actually inherited, so cannot be un-owned
vn = scls.get_verbosename(schema, with_parent=True)
sn = type(scls).get_schema_class_displayname().upper()
raise errors.InvalidDefinitionError(
f'cannot drop owned {vn}, as it is not inherited, '
f'use DROP {sn} instead',
context=self.source_context,
)
# DROP OWNED requires special handling: the object in question
# must revert all modification made on top of inherited attributes.
bases = scls.get_bases(schema).objects(schema)
schema = self.inherit_fields(
schema,
context,
bases,
ignore_local=True,
)
for refdict in type(scls).get_refdicts():
schema = self._drop_owned_refs(schema, context, refdict)
return schema
def sdl_to_ddl(
schema: s_schema.Schema,
documents: Mapping[str, List[qlast.DDL]],
) -> Tuple[qlast.DDLCommand, ...]:
ddlgraph: DDLGraph = {}
mods: List[qlast.DDLCommand] = []
ctx = LayoutTraceContext(
schema,
local_modules=frozenset(mod for mod in documents),
)
for module_name, declarations in documents.items():
ctx.set_module(module_name)
for decl_ast in declarations:
if isinstance(decl_ast, qlast.CreateObject):
_, fq_name = ctx.get_fq_name(decl_ast)
if isinstance(decl_ast, qlast.CreateObjectType):
ctx.objects[fq_name] = qltracer.ObjectType(fq_name)
elif isinstance(decl_ast, qlast.CreateAlias):
ctx.objects[fq_name] = qltracer.Alias(fq_name)
elif isinstance(decl_ast, qlast.CreateScalarType):
ctx.objects[fq_name] = qltracer.ScalarType(fq_name)
elif isinstance(decl_ast, qlast.CreateLink):
ctx.objects[fq_name] = qltracer.Link(fq_name,
source=None,
target=None)
elif isinstance(decl_ast, qlast.CreateProperty):
ctx.objects[fq_name] = qltracer.Property(fq_name,
source=None,
target=None)
elif isinstance(decl_ast, qlast.CreateFunction):
ctx.objects[fq_name] = qltracer.Function(fq_name)
elif isinstance(decl_ast, qlast.CreateConstraint):
ctx.objects[fq_name] = qltracer.Constraint(fq_name)
elif isinstance(decl_ast, qlast.CreateAnnotation):
ctx.objects[fq_name] = qltracer.Annotation(fq_name)
else:
raise AssertionError(
f'unexpected SDL declaration: {decl_ast}')
for module_name, declarations in documents.items():
ctx.set_module(module_name)
for decl_ast in declarations:
trace_layout(decl_ast, ctx=ctx)
# compute the ancestors graph
for obj_name in ctx.parents.keys():
ctx.ancestors[obj_name] = get_ancestors(obj_name, ctx.ancestors,
ctx.parents)
topological.normalize(
ctx.inh_graph,
merger=_graph_merge_cb, # type: ignore
schema=schema,
)
tracectx = DepTraceContext(schema, ddlgraph, ctx.objects, ctx.parents,
ctx.ancestors, ctx.defdeps, ctx.constraints)
for module_name, declarations in documents.items():
tracectx.set_module(module_name)
# module needs to be created regardless of whether its
# contents are empty or not
mods.append(qlast.CreateModule(name=qlast.ObjectRef(name=module_name)))
for decl_ast in declarations:
trace_dependencies(decl_ast, ctx=tracectx)
try:
ordered = topological.sort(ddlgraph, allow_unresolved=False)
except topological.CycleError as e:
assert isinstance(e.item, s_name.QualName)
node = tracectx.ddlgraph[e.item].item
item_vn = get_verbosename_from_fqname(e.item, tracectx)
if e.path is not None and len(e.path):
# Recursion involving more than one schema object.
rec_vn = get_verbosename_from_fqname(e.path[-1], tracectx)
msg = (f'definition dependency cycle between {rec_vn} '
f'and {item_vn}')
else:
# A single schema object with a recursive definition.
msg = f'{item_vn} is defined recursively'
raise errors.InvalidDefinitionError(msg, context=node.context) from e
return tuple(mods) + tuple(ordered)