def type_to_typeref( schema: s_schema.Schema, t: s_types.Type, *, cache: Optional[Dict[TypeRefCacheKey, irast.TypeRef]] = None, typename: Optional[s_name.QualName] = None, include_descendants: bool = False, include_ancestors: bool = False, _name: Optional[str] = None, ) -> irast.TypeRef: """Return an instance of :class:`ir.ast.TypeRef` for a given type. An IR TypeRef is an object that fully describes a schema type for the purposes of query compilation. Args: schema: A schema instance, in which the type *t* is defined. t: A schema type instance. cache: Optional mapping from (type UUID, typename) to cached IR TypeRefs. typename: Optional name hint to use for the type in the returned TypeRef. If ``None``, the type name is used. include_descendants: Whether to include the description of all material type descendants of *t*. include_ancestors: Whether to include the description of all material type ancestors of *t*. _name: Optional subtype element name if this type is a collection within a Tuple, Returns: A ``TypeRef`` instance corresponding to the given schema type. """ result: irast.TypeRef material_type: s_types.Type key = (t.id, include_descendants, include_ancestors) if cache is not None and typename is None: cached_result = cache.get(key) if cached_result is not None: # If the schema changed due to an ongoing compilation, the name # hint might be outdated. if cached_result.name_hint == t.get_name(schema): return cached_result if t.is_anytuple(schema): result = irast.AnyTupleRef( id=t.id, name_hint=typename or t.get_name(schema), ) elif t.is_any(schema): result = irast.AnyTypeRef( id=t.id, name_hint=typename or t.get_name(schema), ) elif not isinstance(t, s_types.Collection): assert isinstance(t, s_types.InheritingType) union_of = t.get_union_of(schema) if union_of: non_overlapping, union_is_concrete = ( s_utils.get_non_overlapping_union( schema, union_of.objects(schema), ) ) union = frozenset( type_to_typeref(schema, c, cache=cache) for c in non_overlapping ) else: union_is_concrete = False union = frozenset() intersection_of = t.get_intersection_of(schema) if intersection_of: intersection = frozenset( type_to_typeref(schema, c, cache=cache) for c in intersection_of.objects(schema) ) else: intersection = frozenset() schema, material_type = t.material_type(schema) material_typeref: Optional[irast.TypeRef] if material_type != t: material_typeref = type_to_typeref( schema, material_type, include_descendants=include_descendants, include_ancestors=include_ancestors, cache=cache, ) else: material_typeref = None if (isinstance(material_type, s_scalars.ScalarType) and not material_type.get_abstract(schema)): base_type = material_type.get_topmost_concrete_base(schema) if base_type == material_type: base_typeref = None else: assert isinstance(base_type, s_types.Type) base_typeref = type_to_typeref( schema, base_type, cache=cache ) else: base_typeref = None tname = t.get_name(schema) if typename is not None: name = typename else: name = tname common_parent_ref: Optional[irast.TypeRef] if union_of: common_parent = s_utils.get_class_nearest_common_ancestor( schema, union_of.objects(schema)) assert isinstance(common_parent, s_types.Type) common_parent_ref = type_to_typeref( schema, common_parent, cache=cache ) else: common_parent_ref = None descendants: Optional[FrozenSet[irast.TypeRef]] if material_typeref is None and include_descendants: descendants = frozenset( type_to_typeref( schema, child, cache=cache, include_descendants=True, include_ancestors=include_ancestors, ) for child in t.children(schema) if not child.get_is_derived(schema) ) else: descendants = None ancestors: Optional[FrozenSet[irast.TypeRef]] if material_typeref is None and include_ancestors: ancestors = frozenset( type_to_typeref( schema, ancestor, cache=cache, include_descendants=include_descendants, include_ancestors=False ) for ancestor in t.get_ancestors(schema).objects(schema) ) else: ancestors = None result = irast.TypeRef( id=t.id, name_hint=name, material_type=material_typeref, base_type=base_typeref, descendants=descendants, ancestors=ancestors, union=union, union_is_concrete=union_is_concrete, intersection=intersection, common_parent=common_parent_ref, element_name=_name, is_scalar=t.is_scalar(), is_abstract=t.get_abstract(schema), is_view=t.is_view(schema), is_opaque_union=t.get_is_opaque_union(schema), ) elif isinstance(t, s_types.Tuple) and t.is_named(schema): schema, material_type = t.material_type(schema) if material_type != t: material_typeref = type_to_typeref( schema, material_type, cache=cache ) else: material_typeref = None result = irast.TypeRef( id=t.id, name_hint=typename or t.get_name(schema), material_type=material_typeref, element_name=_name, collection=t.schema_name, in_schema=t.get_is_persistent(schema), subtypes=tuple( type_to_typeref(schema, st, _name=sn) # note: no cache for sn, st in t.iter_subtypes(schema) ) ) else: schema, material_type = t.material_type(schema) if material_type != t: material_typeref = type_to_typeref( schema, material_type, cache=cache ) else: material_typeref = None result = irast.TypeRef( id=t.id, name_hint=typename or t.get_name(schema), material_type=material_typeref, element_name=_name, collection=t.schema_name, in_schema=t.get_is_persistent(schema), subtypes=tuple( type_to_typeref(schema, st, cache=cache) for st in t.get_subtypes(schema) ) ) if cache is not None and typename is None and _name is None: # Note: there is no cache for `_name` variants since they are only used # for Tuple subtypes and thus they will be cached on the outer level # anyway. # There's also no variant for types with custom typenames since they # proved to have a very low hit rate. # This way we save on the size of the key tuple. cache[key] = result return result
def ptrref_from_ptrcls( # NoQA: F811 *, schema: s_schema.Schema, ptrcls: s_pointers.PointerLike, direction: s_pointers.PointerDirection = ( s_pointers.PointerDirection.Outbound), cache: Optional[Dict[PtrRefCacheKey, irast.BasePointerRef]] = None, typeref_cache: Optional[Dict[TypeRefCacheKey, irast.TypeRef]] = None, ) -> irast.BasePointerRef: """Return an IR pointer descriptor for a given schema pointer. An IR PointerRef is an object that fully describes a schema pointer for the purposes of query compilation. Args: schema: A schema instance, in which the type *t* is defined. ptrcls: A :class:`schema.pointers.Pointer` instance for which to return the PointerRef. direction: The direction of the pointer in the path expression. Returns: An instance of a subclass of :class:`ir.ast.BasePointerRef` corresponding to the given schema pointer. """ if cache is not None: cached = cache.get((ptrcls, direction)) if cached is not None: return cached kwargs: Dict[str, Any] = {} ircls: Type[irast.BasePointerRef] source_ref: Optional[irast.TypeRef] target_ref: Optional[irast.TypeRef] out_source: Optional[irast.TypeRef] if isinstance(ptrcls, irast.TupleIndirectionLink): ircls = irast.TupleIndirectionPointerRef elif isinstance(ptrcls, irast.TypeIntersectionLink): ircls = irast.TypeIntersectionPointerRef kwargs['optional'] = ptrcls.is_optional() kwargs['is_empty'] = ptrcls.is_empty() kwargs['is_subtype'] = ptrcls.is_subtype() kwargs['rptr_specialization'] = ptrcls.get_rptr_specialization() elif isinstance(ptrcls, s_pointers.Pointer): ircls = irast.PointerRef kwargs['id'] = ptrcls.id else: raise AssertionError(f'unexpected pointer class: {ptrcls}') target = ptrcls.get_far_endpoint(schema, direction) if target is not None and not isinstance(target, irast.TypeRef): assert isinstance(target, s_types.Type) target_ref = type_to_typeref(schema, target, cache=typeref_cache) else: target_ref = target source = ptrcls.get_near_endpoint(schema, direction) source_ptr: Optional[irast.BasePointerRef] if (isinstance(ptrcls, s_props.Property) and isinstance(source, s_links.Link)): source_ptr = ptrref_from_ptrcls( ptrcls=source, direction=direction, schema=schema, cache=cache, typeref_cache=typeref_cache, ) source_ref = None else: if source is not None and not isinstance(source, irast.TypeRef): assert isinstance(source, s_types.Type) source_ref = type_to_typeref(schema, source, cache=typeref_cache) else: source_ref = source source_ptr = None if direction is s_pointers.PointerDirection.Inbound: out_source = target_ref out_target = source_ref else: out_source = source_ref out_target = target_ref out_cardinality, dir_cardinality = cardinality_from_ptrcls( schema, ptrcls, direction=direction) schema, material_ptrcls = ptrcls.material_type(schema) material_ptr: Optional[irast.BasePointerRef] if material_ptrcls is not None and material_ptrcls != ptrcls: material_ptr = ptrref_from_ptrcls( ptrcls=material_ptrcls, direction=direction, schema=schema, cache=cache, typeref_cache=typeref_cache, ) else: material_ptr = None union_components: Set[irast.BasePointerRef] = set() union_of = ptrcls.get_union_of(schema) union_is_concrete = False if union_of: union_ptrs = set() for component in union_of.objects(schema): assert isinstance(component, s_pointers.Pointer) schema, material_comp = component.material_type(schema) union_ptrs.add(material_comp) non_overlapping, union_is_concrete = s_utils.get_non_overlapping_union( schema, union_ptrs, ) union_components = { ptrref_from_ptrcls( ptrcls=p, direction=direction, schema=schema, cache=cache, typeref_cache=typeref_cache, ) for p in non_overlapping } intersection_components: Set[irast.BasePointerRef] = set() intersection_of = ptrcls.get_intersection_of(schema) if intersection_of: intersection_ptrs = set() for component in intersection_of.objects(schema): assert isinstance(component, s_pointers.Pointer) schema, material_comp = component.material_type(schema) intersection_ptrs.add(material_comp) intersection_components = { ptrref_from_ptrcls( ptrcls=p, direction=direction, schema=schema, cache=cache, typeref_cache=typeref_cache, ) for p in intersection_ptrs } std_parent_name = None for ancestor in ptrcls.get_ancestors(schema).objects(schema): ancestor_name = ancestor.get_name(schema) if ancestor_name.module == 'std' and ancestor.generic(schema): std_parent_name = ancestor_name break is_derived = ptrcls.get_is_derived(schema) base_ptr: Optional[irast.BasePointerRef] if is_derived: base_ptrcls = ptrcls.get_bases(schema).first(schema) top_ptr_name = type(base_ptrcls).get_default_base_name() if base_ptrcls.get_name(schema) != top_ptr_name: base_ptr = ptrref_from_ptrcls( ptrcls=base_ptrcls, direction=direction, schema=schema, cache=cache, typeref_cache=typeref_cache, ) else: base_ptr = None else: base_ptr = None if ( material_ptr is None and isinstance(ptrcls, s_pointers.Pointer) ): descendants = frozenset( ptrref_from_ptrcls( ptrcls=child, direction=direction, schema=schema, cache=cache, typeref_cache=typeref_cache, ) for child in ptrcls.children(schema) if not child.get_is_derived(schema) ) else: descendants = frozenset() kwargs.update(dict( out_source=out_source, out_target=out_target, name=ptrcls.get_name(schema), shortname=ptrcls.get_shortname(schema), path_id_name=ptrcls.get_path_id_name(schema), std_parent_name=std_parent_name, direction=direction, source_ptr=source_ptr, base_ptr=base_ptr, material_ptr=material_ptr, descendants=descendants, is_derived=ptrcls.get_is_derived(schema), is_computable=ptrcls.get_computable(schema), union_components=union_components, intersection_components=intersection_components, union_is_concrete=union_is_concrete, has_properties=ptrcls.has_user_defined_properties(schema), dir_cardinality=dir_cardinality, out_cardinality=out_cardinality, )) ptrref = ircls(**kwargs) if cache is not None: cache[ptrcls, direction] = ptrref return ptrref
def type_to_typeref( schema: s_schema.Schema, t: s_types.Type, *, cache: Optional[Dict[uuid.UUID, irast.TypeRef]] = None, typename: Optional[s_name.Name] = None, _name: Optional[str] = None, ) -> irast.TypeRef: """Return an instance of :class:`ir.ast.TypeRef` for a given type. An IR TypeRef is an object that fully describes a schema type for the purposes of query compilation. Args: schema: A schema instance, in which the type *t* is defined. t: A schema type instance. cache: Optional mapping from (type UUID, typename) to cached IR TypeRefs. typename: Optional name hint to use for the type in the returned TypeRef. If ``None``, the type name is used. _name: Optional subtype element name if this type is a collection within a Tuple, Returns: A ``TypeRef`` instance corresponding to the given schema type. """ result: irast.TypeRef if cache is not None and typename is None: cached_result = cache.get(t.id) if cached_result is not None: # If the schema changed due to an ongoing compilation, the name # hint might be outdated. if cached_result.name_hint == t.get_name(schema): return cached_result if t.is_anytuple(): result = irast.AnyTupleRef( id=t.id, name_hint=typename or t.get_name(schema), ) elif t.is_any(): result = irast.AnyTypeRef( id=t.id, name_hint=typename or t.get_name(schema), ) elif not isinstance(t, s_abc.Collection): union_of = t.get_union_of(schema) if union_of: non_overlapping, union_is_concrete = ( s_utils.get_non_overlapping_union( schema, union_of.objects(schema), )) union = frozenset( type_to_typeref(schema, c, cache=cache) for c in non_overlapping) else: union_is_concrete = False union = frozenset() intersection_of = t.get_intersection_of(schema) if intersection_of: intersection = frozenset( type_to_typeref(schema, c, cache=cache) for c in intersection_of.objects(schema)) else: intersection = frozenset() material_type = t.material_type(schema) material_typeref: Optional[irast.TypeRef] if material_type is not t: material_typeref = type_to_typeref(schema, material_type, cache=cache) else: material_typeref = None if (isinstance(material_type, s_scalars.ScalarType) and not material_type.get_is_abstract(schema)): base_type = material_type.get_topmost_concrete_base(schema) if base_type is material_type: base_typeref = None else: assert isinstance(base_type, s_types.Type) base_typeref = type_to_typeref(schema, base_type, cache=cache) else: base_typeref = None if typename is not None: name = typename else: name = t.get_name(schema) module = schema.get_global(s_mod.Module, name.module) common_parent_ref: Optional[irast.TypeRef] if union_of: common_parent = s_utils.get_class_nearest_common_ancestor( schema, union_of.objects(schema)) assert isinstance(common_parent, s_types.Type) common_parent_ref = type_to_typeref(schema, common_parent, cache=cache) else: common_parent_ref = None result = irast.TypeRef( id=t.id, module_id=module.id, name_hint=name, material_type=material_typeref, base_type=base_typeref, union=union, union_is_concrete=union_is_concrete, intersection=intersection, common_parent=common_parent_ref, element_name=_name, is_scalar=t.is_scalar(), is_abstract=t.get_is_abstract(schema), is_view=t.is_view(schema), is_opaque_union=t.get_is_opaque_union(schema), ) elif isinstance(t, s_abc.Tuple) and t.named: result = irast.TypeRef( id=t.id, name_hint=typename or t.get_name(schema), element_name=_name, collection=t.schema_name, in_schema=schema.get_by_id(t.id, None) is not None, subtypes=tuple( type_to_typeref(schema, st, _name=sn) # note: no cache for sn, st in t.iter_subtypes(schema))) else: result = irast.TypeRef(id=t.id, name_hint=typename or t.get_name(schema), element_name=_name, collection=t.schema_name, in_schema=schema.get_by_id(t.id, None) is not None, subtypes=tuple( type_to_typeref(schema, st, cache=cache) for st in t.get_subtypes(schema))) if cache is not None and typename is None and _name is None: # Note: there is no cache for `_name` variants since they are only used # for Tuple subtypes and thus they will be cached on the outer level # anyway. # There's also no variant for types with custom typenames since they # proved to have a very low hit rate. # This way we save on the size of the key tuple. cache[t.id] = result return result