def get_config_type_shape(
schema: s_schema.Schema,
stype: s_objtypes.ObjectType,
path: List[qlast.Base],
) -> List[qlast.ShapeElement]:
from . import objtypes as s_objtypes
shape = []
seen: Set[str] = set()
stypes = [stype] + list(stype.descendants(schema))
for t in stypes:
t_name = t.get_name(schema)
for unqual_pn, p in t.get_pointers(schema).items(schema):
pn = str(unqual_pn)
if pn in ('id', '__type__') or pn in seen:
continue
elem_path: List[qlast.Base] = []
if t != stype:
elem_path.append(
qlast.TypeIntersection(type=qlast.TypeName(
maintype=qlast.ObjectRef(
module=t_name.module,
name=t_name.name,
), ), ), )
elem_path.append(qlast.Ptr(ptr=qlast.ObjectRef(name=pn)))
ptype = p.get_target(schema)
assert ptype is not None
if isinstance(ptype, s_objtypes.ObjectType):
subshape = get_config_type_shape(schema, ptype,
path + elem_path)
subshape.append(
qlast.ShapeElement(
expr=qlast.Path(steps=[
qlast.Ptr(ptr=qlast.ObjectRef(name='_tname'), ),
], ),
compexpr=qlast.Path(steps=path + elem_path + [
qlast.Ptr(ptr=qlast.ObjectRef(name='__type__')),
qlast.Ptr(ptr=qlast.ObjectRef(name='name')),
], ),
), )
else:
subshape = []
shape.append(
qlast.ShapeElement(
expr=qlast.Path(steps=elem_path),
elements=subshape,
), )
seen.add(pn)
return shape
def get_config_type_shape(schema, stype,
path) -> typing.List[qlast.ShapeElement]:
shape = []
seen = set()
stypes = [stype] + list(stype.descendants(schema))
for t in stypes:
t_name = t.get_name(schema)
for pn, p in t.get_pointers(schema).items(schema):
if pn in ('id', '__type__') or pn in seen:
continue
elem_path = []
if t is not stype:
elem_path.append(
qlast.TypeIndirection(type=qlast.TypeName(
maintype=qlast.ObjectRef(
module=t_name.module,
name=t_name.name,
), ), ), )
elem_path.append(qlast.Ptr(ptr=qlast.ObjectRef(name=pn)))
ptype = p.get_target(schema)
if ptype.is_object_type():
subshape = get_config_type_shape(schema, ptype,
path + elem_path)
subshape.append(
qlast.ShapeElement(
expr=qlast.Path(steps=[
qlast.Ptr(ptr=qlast.ObjectRef(name='_tname'), ),
], ),
compexpr=qlast.Path(steps=path + elem_path + [
qlast.Ptr(ptr=qlast.ObjectRef(name='__type__')),
qlast.Ptr(ptr=qlast.ObjectRef(name='name')),
], ),
), )
else:
subshape = []
shape.append(
qlast.ShapeElement(
expr=qlast.Path(steps=elem_path),
elements=subshape,
), )
seen.add(pn)
return shape
def _inject_tname(
insert_stmt: qlast.InsertQuery, *,
ctx: context.ContextLevel) -> None:
for el in insert_stmt.shape:
if isinstance(el.compexpr, qlast.InsertQuery):
_inject_tname(el.compexpr, ctx=ctx)
assert isinstance(insert_stmt.subject.steps[0], qlast.BaseObjectRef)
insert_stmt.shape.append(
qlast.ShapeElement(
expr=qlast.Path(
steps=[qlast.Ptr(ptr=qlast.ObjectRef(name='_tname'))],
),
compexpr=qlast.Path(
steps=[
qlast.Introspect(
type=qlast.TypeName(
maintype=insert_stmt.subject.steps[0],
),
),
qlast.Ptr(ptr=qlast.ObjectRef(name='name')),
],
),
),
)
def _inline_type_computable(
ir_set: irast.Set,
stype: s_objtypes.ObjectType,
compname: str,
propname: str,
*,
shape_ptrs: List[ShapePtr],
ctx: context.ContextLevel,
) -> None:
assert isinstance(stype, s_objtypes.ObjectType)
ptr: Optional[s_pointers.Pointer]
try:
ptr = setgen.resolve_ptr(stype, compname, track_ref=None, ctx=ctx)
# The pointer might exist on the base type. That doesn't count,
# and we need to re-inject it.
if not ptr.get_computable(ctx.env.schema):
ptr = None
except errors.InvalidReferenceError:
ptr = None
if ptr is None:
ql = qlast.ShapeElement(
expr=qlast.Path(
steps=[qlast.Ptr(
ptr=qlast.ObjectRef(name=compname),
direction=s_pointers.PointerDirection.Outbound,
)],
),
compexpr=qlast.Path(
steps=[
qlast.Source(),
qlast.Ptr(
ptr=qlast.ObjectRef(name='__type__'),
direction=s_pointers.PointerDirection.Outbound,
),
qlast.Ptr(
ptr=qlast.ObjectRef(name=propname),
direction=s_pointers.PointerDirection.Outbound,
)
]
)
)
with ctx.newscope(fenced=True) as scopectx:
scopectx.anchors = scopectx.anchors.copy()
scopectx.anchors[qlast.Source().name] = ir_set
ptr = _normalize_view_ptr_expr(
ql, stype, path_id=ir_set.path_id, ctx=scopectx)
view_shape = ctx.env.view_shapes[stype]
view_shape_ptrs = {p for p, _ in view_shape}
if ptr not in view_shape_ptrs:
view_shape.insert(0, (ptr, qlast.ShapeOp.ASSIGN))
shape_ptrs.insert(0, (ir_set, ptr, qlast.ShapeOp.ASSIGN))
def make_free_object(els: Dict[str, qlast.Expr]) -> qlast.Shape:
return qlast.Shape(
expr=None,
elements=[
qlast.ShapeElement(
expr=qlast.Path(
steps=[qlast.Ptr(ptr=qlast.ObjectRef(name=name))]),
compexpr=expr
)
for name, expr in els.items()
],
)
def visit_Set(self, node):
if node.expr is not None:
result = self.visit(node.expr)
else:
result = self._visit_path(node)
if node.shape:
result = qlast.Shape(expr=result, elements=[])
for el in node.shape:
rptr = el.rptr
ptrref = rptr.ptrref
pn = ptrref.shortname
pn = qlast.ShapeElement(expr=qlast.Path(steps=[
qlast.Ptr(ptr=qlast.ObjectRef(name=pn.name),
direction=rptr.direction)
]))
result.elements.append(pn)
return result
def _process_view(
*,
stype: s_objtypes.ObjectType,
path_id: irast.PathId,
path_id_namespace: Optional[irast.WeakNamespace] = None,
elements: List[qlast.ShapeElement],
view_rptr: Optional[context.ViewRPtr] = None,
view_name: Optional[sn.QualName] = None,
is_insert: bool = False,
is_update: bool = False,
is_delete: bool = False,
parser_context: pctx.ParserContext,
ctx: context.ContextLevel,
) -> s_objtypes.ObjectType:
if (view_name is None and ctx.env.options.schema_view_mode
and view_rptr is not None):
# Make sure persistent schema expression aliases have properly formed
# names as opposed to the usual mangled form of the ephemeral
# aliases. This is needed for introspection readability, as well
# as helps in maintaining proper type names for schema
# representations that require alphanumeric names, such as
# GraphQL.
#
# We use the name of the source together with the name
# of the inbound link to form the name, so in e.g.
# CREATE ALIAS V := (SELECT Foo { bar: { baz: { ... } })
# The name of the innermost alias would be "__V__bar__baz".
source_name = view_rptr.source.get_name(ctx.env.schema).name
if not source_name.startswith('__'):
source_name = f'__{source_name}'
if view_rptr.ptrcls_name is not None:
ptr_name = view_rptr.ptrcls_name.name
elif view_rptr.ptrcls is not None:
ptr_name = view_rptr.ptrcls.get_shortname(ctx.env.schema).name
else:
raise errors.InternalServerError(
'_process_view in schema mode received view_rptr with '
'neither ptrcls_name, not ptrcls'
)
name = f'{source_name}__{ptr_name}'
view_name = sn.QualName(
module=ctx.derived_target_module or '__derived__',
name=name,
)
view_scls = schemactx.derive_view(
stype,
is_insert=is_insert,
is_update=is_update,
is_delete=is_delete,
derived_name=view_name,
ctx=ctx,
)
assert isinstance(view_scls, s_objtypes.ObjectType), view_scls
is_mutation = is_insert or is_update
is_defining_shape = ctx.expr_exposed or is_mutation
if view_rptr is not None and view_rptr.ptrcls is None:
derive_ptrcls(
view_rptr, target_scls=view_scls,
transparent=True, ctx=ctx)
pointers = []
for shape_el in elements:
with ctx.newscope(fenced=True) as scopectx:
pointer = _normalize_view_ptr_expr(
shape_el, view_scls, path_id=path_id,
path_id_namespace=path_id_namespace,
is_insert=is_insert, is_update=is_update,
view_rptr=view_rptr,
ctx=scopectx)
if pointer in pointers:
schema = ctx.env.schema
vnp = pointer.get_verbosename(schema, with_parent=True)
raise errors.QueryError(
f'duplicate definition of {vnp}',
context=shape_el.context)
pointers.append(pointer)
if is_insert:
explicit_ptrs = {
ptrcls.get_local_name(ctx.env.schema)
for ptrcls in pointers
}
scls_pointers = stype.get_pointers(ctx.env.schema)
for pn, ptrcls in scls_pointers.items(ctx.env.schema):
if (pn in explicit_ptrs or
ptrcls.is_pure_computable(ctx.env.schema)):
continue
default_expr = ptrcls.get_default(ctx.env.schema)
if not default_expr:
if (
ptrcls.get_required(ctx.env.schema)
and pn != sn.UnqualName('__type__')
):
if ptrcls.is_property(ctx.env.schema):
# If the target is a sequence, there's no need
# for an explicit value.
ptrcls_target = ptrcls.get_target(ctx.env.schema)
assert ptrcls_target is not None
if ptrcls_target.issubclass(
ctx.env.schema,
ctx.env.schema.get(
'std::sequence',
type=s_objects.SubclassableObject)):
continue
vn = ptrcls.get_verbosename(
ctx.env.schema, with_parent=True)
raise errors.MissingRequiredError(
f'missing value for required {vn}')
else:
continue
ptrcls_sn = ptrcls.get_shortname(ctx.env.schema)
default_ql = qlast.ShapeElement(
expr=qlast.Path(
steps=[
qlast.Ptr(
ptr=qlast.ObjectRef(
name=ptrcls_sn.name,
module=ptrcls_sn.module,
),
),
],
),
compexpr=qlast.DetachedExpr(
expr=default_expr.qlast,
),
)
with ctx.newscope(fenced=True) as scopectx:
pointers.append(
_normalize_view_ptr_expr(
default_ql,
view_scls,
path_id=path_id,
path_id_namespace=path_id_namespace,
is_insert=is_insert,
is_update=is_update,
from_default=True,
view_rptr=view_rptr,
ctx=scopectx,
),
)
elif (
stype.get_name(ctx.env.schema).module == 'schema'
and ctx.env.options.apply_query_rewrites
):
explicit_ptrs = {
ptrcls.get_local_name(ctx.env.schema)
for ptrcls in pointers
}
scls_pointers = stype.get_pointers(ctx.env.schema)
for pn, ptrcls in scls_pointers.items(ctx.env.schema):
if (
pn in explicit_ptrs
or ptrcls.is_pure_computable(ctx.env.schema)
):
continue
schema_deflt = ptrcls.get_schema_reflection_default(ctx.env.schema)
if schema_deflt is None:
continue
with ctx.newscope(fenced=True) as scopectx:
ptr_ref = s_utils.name_to_ast_ref(pn)
implicit_ql = qlast.ShapeElement(
expr=qlast.Path(steps=[qlast.Ptr(ptr=ptr_ref)]),
compexpr=qlast.BinOp(
left=qlast.Path(
partial=True,
steps=[
qlast.Ptr(
ptr=ptr_ref,
direction=(
s_pointers.PointerDirection.Outbound
),
)
],
),
right=qlparser.parse_fragment(schema_deflt),
op='??',
),
)
# Note: we only need to record the schema default
# as a computable, but not include it in the type
# shape, so we ignore the return value.
_normalize_view_ptr_expr(
implicit_ql,
view_scls,
path_id=path_id,
path_id_namespace=path_id_namespace,
is_insert=is_insert,
is_update=is_update,
view_rptr=view_rptr,
ctx=scopectx,
)
for ptrcls in pointers:
source: Union[s_types.Type, s_pointers.PointerLike]
if ptrcls.is_link_property(ctx.env.schema):
assert view_rptr is not None and view_rptr.ptrcls is not None
source = view_rptr.ptrcls
else:
source = view_scls
if is_defining_shape:
cinfo = ctx.source_map.get(ptrcls)
if cinfo is not None:
shape_op = cinfo.shape_op
else:
shape_op = qlast.ShapeOp.ASSIGN
ctx.env.view_shapes[source].append((ptrcls, shape_op))
if (view_rptr is not None and view_rptr.ptrcls is not None and
view_scls != stype):
ctx.env.schema = view_scls.set_field_value(
ctx.env.schema, 'rptr', view_rptr.ptrcls)
return view_scls
def _get_shape_configuration(
ir_set: irast.Set,
*,
rptr: Optional[irast.Pointer]=None,
parent_view_type: Optional[s_types.ExprType]=None,
ctx: context.ContextLevel
) -> List[Tuple[irast.Set, s_pointers.Pointer, qlast.ShapeOp]]:
"""Return a list of (source_set, ptrcls) pairs as a shape for a given set.
"""
stype = setgen.get_set_type(ir_set, ctx=ctx)
sources: List[
Union[s_types.Type, s_pointers.PointerLike]] = []
link_view = False
is_objtype = ir_set.path_id.is_objtype_path()
if rptr is None:
rptr = ir_set.rptr
if rptr is not None:
rptrcls = typegen.ptrcls_from_ptrref(rptr.ptrref, ctx=ctx)
else:
rptrcls = None
link_view = (
rptrcls is not None and
not rptrcls.is_link_property(ctx.env.schema) and
_link_has_shape(rptrcls, ctx=ctx)
)
if is_objtype or not link_view:
sources.append(stype)
if link_view:
sources.append(rptrcls)
shape_ptrs = []
for source in sources:
for ptr, shape_op in ctx.env.view_shapes[source]:
if (ptr.is_link_property(ctx.env.schema) and
ir_set.path_id != rptr.target.path_id):
path_tip = rptr.target
else:
path_tip = ir_set
shape_ptrs.append((path_tip, ptr, shape_op))
if is_objtype:
assert isinstance(stype, s_objtypes.ObjectType)
view_type = stype.get_expr_type(ctx.env.schema)
is_mutation = view_type in (s_types.ExprType.Insert,
s_types.ExprType.Update)
is_parent_update = parent_view_type is s_types.ExprType.Update
implicit_id = (
# shape is not specified at all
not shape_ptrs
# implicit ids are always wanted
or (ctx.implicit_id_in_shapes and not is_mutation)
# we are inside an UPDATE shape and this is
# an explicit expression (link target update)
or (is_parent_update and ir_set.expr is not None)
)
if implicit_id:
# We want the id in this shape and it's not already there,
# so insert it in the first position.
pointers = stype.get_pointers(ctx.env.schema).objects(
ctx.env.schema)
view_shape = ctx.env.view_shapes[stype]
view_shape_ptrs = {p for p, _ in view_shape}
for ptr in pointers:
if ptr.is_id_pointer(ctx.env.schema):
if ptr not in view_shape_ptrs:
shape_metadata = ctx.env.view_shapes_metadata[stype]
view_shape.insert(0, (ptr, qlast.ShapeOp.ASSIGN))
shape_metadata.has_implicit_id = True
shape_ptrs.insert(
0, (ir_set, ptr, qlast.ShapeOp.ASSIGN))
break
is_mutation = parent_view_type in {
s_types.ExprType.Insert,
s_types.ExprType.Update
}
implicit_tid = (
stype is not None
and has_implicit_tid(stype, is_mutation=is_mutation, ctx=ctx)
)
if implicit_tid:
assert isinstance(stype, s_objtypes.ObjectType)
try:
ptr = setgen.resolve_ptr(stype, '__tid__', ctx=ctx)
except errors.InvalidReferenceError:
ql = qlast.ShapeElement(
expr=qlast.Path(
steps=[qlast.Ptr(
ptr=qlast.ObjectRef(name='__tid__'),
direction=s_pointers.PointerDirection.Outbound,
)],
),
compexpr=qlast.Path(
steps=[
qlast.Source(),
qlast.Ptr(
ptr=qlast.ObjectRef(name='__type__'),
direction=s_pointers.PointerDirection.Outbound,
),
qlast.Ptr(
ptr=qlast.ObjectRef(name='id'),
direction=s_pointers.PointerDirection.Outbound,
)
]
)
)
with ctx.newscope(fenced=True) as scopectx:
scopectx.anchors = scopectx.anchors.copy()
scopectx.anchors[qlast.Source().name] = ir_set
ptr = _normalize_view_ptr_expr(
ql, stype, path_id=ir_set.path_id, ctx=scopectx)
view_shape = ctx.env.view_shapes[stype]
view_shape_ptrs = {p for p, _ in view_shape}
if ptr not in view_shape_ptrs:
view_shape.insert(0, (ptr, qlast.ShapeOp.ASSIGN))
shape_ptrs.insert(0, (ir_set, ptr, qlast.ShapeOp.ASSIGN))
return shape_ptrs
def _process_view(*,
stype: s_nodes.Node,
path_id: irast.PathId,
path_id_namespace: typing.Optional[
irast.WeakNamespace] = None,
elements: typing.List[qlast.ShapeElement],
view_rptr: typing.Optional[context.ViewRPtr] = None,
view_name: typing.Optional[sn.SchemaName] = None,
is_insert: bool = False,
is_update: bool = False,
ctx: context.CompilerContext) -> s_nodes.Node:
view_scls = schemactx.derive_view(stype,
is_insert=is_insert,
is_update=is_update,
derived_name=view_name,
ctx=ctx)
is_mutation = is_insert or is_update
is_defining_shape = ctx.expr_exposed or is_mutation
if view_rptr is not None and view_rptr.ptrcls is None:
derive_ptrcls(view_rptr,
target_scls=view_scls,
transparent=True,
ctx=ctx)
pointers = []
for shape_el in elements:
with ctx.newscope(fenced=True) as scopectx:
pointers.append(
_normalize_view_ptr_expr(shape_el,
view_scls,
path_id=path_id,
path_id_namespace=path_id_namespace,
is_insert=is_insert,
is_update=is_update,
view_rptr=view_rptr,
ctx=scopectx))
if is_insert:
explicit_ptrs = {
ptrcls.get_shortname(ctx.env.schema).name
for ptrcls in pointers
}
scls_pointers = stype.get_pointers(ctx.env.schema)
for pn, ptrcls in scls_pointers.items(ctx.env.schema):
if (pn in explicit_ptrs
or ptrcls.is_pure_computable(ctx.env.schema)):
continue
if not ptrcls.get_default(ctx.env.schema):
if ptrcls.get_required(ctx.env.schema):
if ptrcls.is_property(ctx.env.schema):
what = 'property'
else:
what = 'link'
raise errors.MissingRequiredError(
f'missing value for required {what} '
f'{stype.get_displayname(ctx.env.schema)}.'
f'{ptrcls.get_displayname(ctx.env.schema)}')
else:
continue
ptrcls_sn = ptrcls.get_shortname(ctx.env.schema)
default_ql = qlast.ShapeElement(expr=qlast.Path(steps=[
qlast.Ptr(ptr=qlast.ObjectRef(name=ptrcls_sn.name,
module=ptrcls_sn.module))
]))
with ctx.newscope(fenced=True) as scopectx:
pointers.append(
_normalize_view_ptr_expr(
default_ql,
view_scls,
path_id=path_id,
path_id_namespace=path_id_namespace,
is_insert=is_insert,
is_update=is_update,
view_rptr=view_rptr,
ctx=scopectx))
for ptrcls in pointers:
if ptrcls.is_link_property(ctx.env.schema):
source = view_rptr.ptrcls
else:
source = view_scls
if is_defining_shape:
ctx.env.view_shapes[source].append(ptrcls)
if (view_rptr is not None and view_rptr.ptrcls is not None
and view_scls is not stype):
ctx.env.schema = view_scls.set_field_value(ctx.env.schema, 'rptr',
view_rptr.ptrcls)
return view_scls
def reduce_ShapePath(self, *kids):
self.val = qlast.ShapeElement(expr=kids[0].val)
def _process_view(*,
stype: s_nodes.Node,
path_id: irast.PathId,
path_id_namespace: typing.Optional[
irast.WeakNamespace] = None,
elements: typing.List[qlast.ShapeElement],
view_rptr: typing.Optional[context.ViewRPtr] = None,
view_name: typing.Optional[sn.SchemaName] = None,
is_insert: bool = False,
is_update: bool = False,
ctx: context.CompilerContext) -> s_nodes.Node:
view_scls = schemactx.derive_view(stype,
is_insert=is_insert,
is_update=is_update,
derived_name=view_name,
ctx=ctx)
is_mutation = is_insert or is_update
is_defining_shape = ctx.expr_exposed or is_mutation
pointers = []
for shape_el in elements:
with ctx.newscope(fenced=True) as scopectx:
pointers.append(
_normalize_view_ptr_expr(shape_el,
view_scls,
path_id=path_id,
path_id_namespace=path_id_namespace,
is_insert=is_insert,
is_update=is_update,
view_rptr=view_rptr,
ctx=scopectx))
if is_insert:
explicit_ptrs = {
ptrcls.get_shortname(ctx.env.schema).name
for ptrcls in pointers
}
scls_pointers = stype.get_pointers(ctx.env.schema)
for pn, ptrcls in scls_pointers.items(ctx.env.schema):
if (pn in explicit_ptrs
or ptrcls.is_pure_computable(ctx.env.schema)):
continue
if not ptrcls.get_default(ctx.env.schema):
if ptrcls.get_required(ctx.env.schema):
if ptrcls.is_property(ctx.env.schema):
what = 'property'
else:
what = 'link'
raise errors.MissingRequiredError(
f'missing value for required {what} '
f'{stype.get_displayname(ctx.env.schema)}.'
f'{ptrcls.get_displayname(ctx.env.schema)}')
else:
continue
ptrcls_sn = ptrcls.get_shortname(ctx.env.schema)
default_ql = qlast.ShapeElement(expr=qlast.Path(steps=[
qlast.Ptr(ptr=qlast.ObjectRef(name=ptrcls_sn.name,
module=ptrcls_sn.module))
]))
with ctx.newscope(fenced=True) as scopectx:
pointers.append(
_normalize_view_ptr_expr(
default_ql,
view_scls,
path_id=path_id,
path_id_namespace=path_id_namespace,
is_insert=is_insert,
is_update=is_update,
view_rptr=view_rptr,
ctx=scopectx))
for ptrcls in pointers:
if ptrcls.is_link_property(ctx.env.schema):
source = view_rptr.derived_ptrcls
else:
source = view_scls
if ptrcls.get_source(ctx.env.schema) is source:
ctx.env.schema = source.add_pointer(ctx.env.schema,
ptrcls,
replace=True)
if is_defining_shape:
if source is None:
# The nested shape is merely selecting the pointer,
# so the link class has not been derived. But for
# the purposes of shape tracking, we must derive it
# still. The derived pointer must be treated the same
# as the original, as this is not a new computable,
# and both `Foo.ptr` and `Foo { ptr }` are the same path,
# hence the `transparent` modifier.
source = derive_ptrcls(view_rptr,
target_scls=view_scls,
transparent=True,
ctx=ctx)
ctx.env.view_shapes[source].append(ptrcls)
if (view_rptr is not None and view_rptr.derived_ptrcls is not None
and view_scls is not stype):
ctx.env.schema = view_scls.set_field_value(ctx.env.schema, 'rptr',
view_rptr.derived_ptrcls)
return view_scls
def _get_shape_configuration(
ir_set: irast.Set, *,
rptr: typing.Optional[irast.Pointer]=None,
parent_view_type: typing.Optional[s_types.ViewType]=None,
ctx: context.ContextLevel) \
-> typing.List[typing.Tuple[irast.Set, s_pointers.Pointer]]:
"""Return a list of (source_set, ptrcls) pairs as a shape for a given set.
"""
stype = setgen.get_set_type(ir_set, ctx=ctx)
sources = []
link_view = False
is_objtype = ir_set.path_id.is_objtype_path()
if rptr is None:
rptr = ir_set.rptr
if rptr is not None:
rptrcls = irtyputils.ptrcls_from_ptrref(rptr.ptrref,
schema=ctx.env.schema)
else:
rptrcls = None
link_view = (rptrcls is not None
and not rptrcls.is_link_property(ctx.env.schema)
and _link_has_shape(rptrcls, ctx=ctx))
if is_objtype or not link_view:
sources.append(stype)
if link_view:
sources.append(rptrcls)
shape_ptrs = []
id_present_in_shape = False
for source in sources:
for ptr in ctx.env.view_shapes[source]:
if (ptr.is_link_property(ctx.env.schema)
and ir_set.path_id != rptr.target.path_id):
path_tip = rptr.target
else:
path_tip = ir_set
shape_ptrs.append((path_tip, ptr))
if source is stype and ptr.is_id_pointer(ctx.env.schema):
id_present_in_shape = True
if is_objtype and not id_present_in_shape:
view_type = stype.get_view_type(ctx.env.schema)
is_mutation = view_type in (s_types.ViewType.Insert,
s_types.ViewType.Update)
is_parent_update = parent_view_type is s_types.ViewType.Update
implicit_id = (
# shape is not specified at all
not shape_ptrs
# implicit ids are always wanted
or (ctx.implicit_id_in_shapes and not is_mutation)
# we are inside an UPDATE shape and this is
# an explicit expression (link target update)
or (is_parent_update and ir_set.expr is not None))
if implicit_id:
# We want the id in this shape and it's not already there,
# so insert it in the first position.
pointers = stype.get_pointers(ctx.env.schema).objects(
ctx.env.schema)
for ptr in pointers:
if ptr.is_id_pointer(ctx.env.schema):
view_shape = ctx.env.view_shapes[stype]
if ptr not in view_shape:
shape_metadata = ctx.env.view_shapes_metadata[stype]
view_shape.insert(0, ptr)
shape_metadata.has_implicit_id = True
shape_ptrs.insert(0, (ir_set, ptr))
break
if (ir_set.typeref is not None and irtyputils.is_object(ir_set.typeref)
and parent_view_type is not s_types.ViewType.Insert
and parent_view_type is not s_types.ViewType.Update
and ctx.implicit_tid_in_shapes):
ql = qlast.ShapeElement(
expr=qlast.Path(steps=[
qlast.Ptr(
ptr=qlast.ObjectRef(name='__tid__'),
direction=s_pointers.PointerDirection.Outbound,
)
], ),
compexpr=qlast.Path(steps=[
qlast.Source(),
qlast.Ptr(
ptr=qlast.ObjectRef(name='__type__'),
direction=s_pointers.PointerDirection.Outbound,
),
qlast.Ptr(
ptr=qlast.ObjectRef(name='id'),
direction=s_pointers.PointerDirection.Outbound,
)
]))
with ctx.newscope(fenced=True) as scopectx:
scopectx.anchors = scopectx.anchors.copy()
scopectx.anchors[qlast.Source] = ir_set
ptr = _normalize_view_ptr_expr(ql,
stype,
path_id=ir_set.path_id,
ctx=scopectx)
view_shape = ctx.env.view_shapes[stype]
if ptr not in view_shape:
view_shape.insert(0, ptr)
shape_ptrs.insert(0, (ir_set, ptr))
return shape_ptrs
def visit_Field(self, node):
if self._is_duplicate_field(node):
return
is_top, path, prevt, target, steps = \
self._prepare_field(node)
json_mode = False
is_shadowed = prevt.is_field_shadowed(node.name.value)
# determine if there needs to be extra subqueries
if not prevt.dummy and target.dummy:
json_mode = True
# this is a special introspection type
eql, shape, filterable = target.get_template()
spec = qlast.ShapeElement(
expr=qlast.Path(steps=[
qlast.Ptr(ptr=qlast.ObjectRef(
name=(node.alias or node.name).value))
]),
compexpr=eql,
)
elif is_shadowed and not node.alias:
# shadowed field that doesn't need an alias
spec = filterable = shape = qlast.ShapeElement(
expr=qlast.Path(steps=steps), )
elif not node.selection_set or is_shadowed and node.alias:
# this is either an unshadowed terminal field or an aliased
# shadowed field
prefix = qlast.Path(steps=self.get_path_prefix(-1))
eql, shape, filterable = prevt.get_field_template(
node.name.value,
parent=prefix,
has_shape=bool(node.selection_set))
spec = qlast.ShapeElement(
expr=qlast.Path(steps=[
qlast.Ptr(ptr=qlast.ObjectRef(
# this is already a sub-query
name=(node.alias or node.name).value))
]),
compexpr=eql,
# preserve the original cardinality of the computable
# aliased fields
cardinality=prevt.get_field_cardinality(node.name.value),
)
else:
# if the parent is NOT a shadowed type, we need an explicit SELECT
eql, shape, filterable = target.get_template()
spec = qlast.ShapeElement(
expr=qlast.Path(steps=[
qlast.Ptr(ptr=qlast.ObjectRef(
# this is already a sub-query
name=(node.alias or node.name).value))
]),
compexpr=eql,
# preserve the original cardinality of the computable,
# which is basically one of the top-level query
# fields, all of which are returning lists
cardinality=qltypes.Cardinality.MANY,
)
if node.selection_set is not None:
if not json_mode:
# a single recursion target, so we can process
# selection set now
self._context.fields.append({})
vals = self.visit(node.selection_set)
self._context.fields.pop()
if shape:
shape.elements = vals
if filterable:
where, orderby, offset, limit = \
self._visit_arguments(node.arguments)
filterable.where = where
filterable.orderby = orderby
filterable.offset = offset
filterable.limit = limit
path.pop()
return spec
def _process_view(*,
stype: s_objtypes.ObjectType,
path_id: irast.PathId,
path_id_namespace: Optional[irast.WeakNamespace] = None,
elements: List[qlast.ShapeElement],
view_rptr: Optional[context.ViewRPtr] = None,
view_name: Optional[sn.SchemaName] = None,
is_insert: bool = False,
is_update: bool = False,
ctx: context.ContextLevel) -> s_objtypes.ObjectType:
if (view_name is None and ctx.env.schema_view_mode
and view_rptr is not None):
# Make sure persistent schema expression aliases have properly formed
# names as opposed to the usual mangled form of the ephemeral
# aliases. This is needed for introspection readability, as well
# as helps in maintaining proper type names for schema
# representations that require alphanumeric names, such as
# GraphQL.
#
# We use the name of the source together with the name
# of the inbound link to form the name, so in e.g.
# CREATE ALIAS V := (SELECT Foo { bar: { baz: { ... } })
# The name of the innermost alias would be "__V__bar__baz".
source_name = view_rptr.source.get_name(ctx.env.schema).name
if not source_name.startswith('__'):
source_name = f'__{source_name}'
if view_rptr.ptrcls_name is not None:
ptr_name = view_rptr.ptrcls_name.name
elif view_rptr.ptrcls is not None:
ptr_name = view_rptr.ptrcls.get_shortname(ctx.env.schema).name
else:
raise errors.InternalServerError(
'_process_view in schema mode received view_rptr with '
'neither ptrcls_name, not ptrcls')
name = f'{source_name}__{ptr_name}'
view_name = sn.Name(
module=ctx.derived_target_module or '__derived__',
name=name,
)
view_scls = schemactx.derive_view(stype,
is_insert=is_insert,
is_update=is_update,
derived_name=view_name,
ctx=ctx)
assert isinstance(view_scls, s_objtypes.ObjectType)
is_mutation = is_insert or is_update
is_defining_shape = ctx.expr_exposed or is_mutation
if view_rptr is not None and view_rptr.ptrcls is None:
derive_ptrcls(view_rptr,
target_scls=view_scls,
transparent=True,
ctx=ctx)
pointers = []
for shape_el in elements:
with ctx.newscope(fenced=True) as scopectx:
pointers.append(
_normalize_view_ptr_expr(shape_el,
view_scls,
path_id=path_id,
path_id_namespace=path_id_namespace,
is_insert=is_insert,
is_update=is_update,
view_rptr=view_rptr,
ctx=scopectx))
if is_insert:
assert isinstance(stype, s_objtypes.ObjectType)
explicit_ptrs = {
ptrcls.get_shortname(ctx.env.schema).name
for ptrcls in pointers
}
scls_pointers = stype.get_pointers(ctx.env.schema)
for pn, ptrcls in scls_pointers.items(ctx.env.schema):
if (pn in explicit_ptrs
or ptrcls.is_pure_computable(ctx.env.schema)):
continue
if not ptrcls.get_default(ctx.env.schema):
if ptrcls.get_required(ctx.env.schema):
if ptrcls.is_property(ctx.env.schema):
# If the target is a sequence, there's no need
# for an explicit value.
if ptrcls.get_target(ctx.env.schema).issubclass(
ctx.env.schema,
ctx.env.schema.get('std::sequence')):
continue
what = 'property'
else:
what = 'link'
raise errors.MissingRequiredError(
f'missing value for required {what} '
f'{stype.get_displayname(ctx.env.schema)}.'
f'{ptrcls.get_displayname(ctx.env.schema)}')
else:
continue
ptrcls_sn = ptrcls.get_shortname(ctx.env.schema)
default_ql = qlast.ShapeElement(expr=qlast.Path(steps=[
qlast.Ptr(ptr=qlast.ObjectRef(name=ptrcls_sn.name,
module=ptrcls_sn.module))
]))
with ctx.newscope(fenced=True) as scopectx:
pointers.append(
_normalize_view_ptr_expr(
default_ql,
view_scls,
path_id=path_id,
path_id_namespace=path_id_namespace,
is_insert=is_insert,
is_update=is_update,
view_rptr=view_rptr,
ctx=scopectx))
for ptrcls in pointers:
source: Union[s_types.Type, s_pointers.PointerLike]
if ptrcls.is_link_property(ctx.env.schema):
assert view_rptr is not None and view_rptr.ptrcls is not None
source = view_rptr.ptrcls
else:
source = view_scls
if is_defining_shape:
ctx.env.view_shapes[source].append(ptrcls)
if (view_rptr is not None and view_rptr.ptrcls is not None
and view_scls is not stype):
ctx.env.schema = view_scls.set_field_value(ctx.env.schema, 'rptr',
view_rptr.ptrcls)
return view_scls
def _process_view(
*,
stype: s_objtypes.ObjectType,
path_id: irast.PathId,
path_id_namespace: Optional[irast.Namespace] = None,
elements: Optional[Sequence[qlast.ShapeElement]],
view_rptr: Optional[context.ViewRPtr] = None,
view_name: Optional[sn.QualName] = None,
is_insert: bool = False,
is_update: bool = False,
is_delete: bool = False,
parser_context: Optional[pctx.ParserContext],
ctx: context.ContextLevel,
) -> s_objtypes.ObjectType:
if (view_name is None and ctx.env.options.schema_view_mode
and view_rptr is not None):
# Make sure persistent schema expression aliases have properly formed
# names as opposed to the usual mangled form of the ephemeral
# aliases. This is needed for introspection readability, as well
# as helps in maintaining proper type names for schema
# representations that require alphanumeric names, such as
# GraphQL.
#
# We use the name of the source together with the name
# of the inbound link to form the name, so in e.g.
# CREATE ALIAS V := (SELECT Foo { bar: { baz: { ... } })
# The name of the innermost alias would be "__V__bar__baz".
source_name = view_rptr.source.get_name(ctx.env.schema).name
if not source_name.startswith('__'):
source_name = f'__{source_name}'
if view_rptr.ptrcls_name is not None:
ptr_name = view_rptr.ptrcls_name.name
elif view_rptr.ptrcls is not None:
ptr_name = view_rptr.ptrcls.get_shortname(ctx.env.schema).name
else:
raise errors.InternalServerError(
'_process_view in schema mode received view_rptr with '
'neither ptrcls_name, not ptrcls'
)
name = f'{source_name}__{ptr_name}'
view_name = sn.QualName(
module=ctx.derived_target_module or '__derived__',
name=name,
)
view_scls = schemactx.derive_view(
stype,
is_insert=is_insert,
is_update=is_update,
is_delete=is_delete,
derived_name=view_name,
ctx=ctx,
)
assert isinstance(view_scls, s_objtypes.ObjectType), view_scls
is_mutation = is_insert or is_update
is_defining_shape = ctx.expr_exposed or is_mutation
if view_rptr is not None and view_rptr.ptrcls is None:
derive_ptrcls(
view_rptr, target_scls=view_scls,
transparent=True, ctx=ctx)
pointers = []
elements = elements or ()
for shape_el in elements:
with ctx.newscope(fenced=True) as scopectx:
pointer = _normalize_view_ptr_expr(
shape_el, view_scls, path_id=path_id,
path_id_namespace=path_id_namespace,
is_insert=is_insert, is_update=is_update,
view_rptr=view_rptr,
ctx=scopectx)
if pointer in pointers:
schema = ctx.env.schema
vnp = pointer.get_verbosename(schema, with_parent=True)
raise errors.QueryError(
f'duplicate definition of {vnp}',
context=shape_el.context)
pointers.append(pointer)
# If we are not defining a shape (so we might care about
# materialization), look through our parent view (if one exists)
# for materialized properties that are not present in this shape.
# If any are found, inject them.
# (See test_edgeql_volatility_rebind_flat_01 for an example.)
schema = ctx.env.schema
base = view_scls.get_bases(schema).objects(schema)[0]
base_ptrs = (view_scls.get_pointers(schema).objects(schema)
if not is_defining_shape else ())
for ptrcls in base_ptrs:
if ptrcls in pointers or base not in ctx.env.view_shapes:
continue
pptr = ptrcls.get_bases(schema).objects(schema)[0]
if (pptr, qlast.ShapeOp.MATERIALIZE) not in ctx.env.view_shapes[base]:
continue
# Make up a dummy shape element
name = ptrcls.get_shortname(schema).name
dummy_el = qlast.ShapeElement(expr=qlast.Path(
steps=[qlast.Ptr(ptr=qlast.ObjectRef(name=name))]))
with ctx.newscope(fenced=True) as scopectx:
pointer = _normalize_view_ptr_expr(
dummy_el, view_scls, path_id=path_id,
path_id_namespace=path_id_namespace,
is_insert=is_insert, is_update=is_update,
view_rptr=view_rptr,
ctx=scopectx)
pointers.append(pointer)
if is_insert:
explicit_ptrs = {
ptrcls.get_local_name(ctx.env.schema)
for ptrcls in pointers
}
scls_pointers = stype.get_pointers(ctx.env.schema)
for pn, ptrcls in scls_pointers.items(ctx.env.schema):
if (pn in explicit_ptrs or
ptrcls.is_pure_computable(ctx.env.schema)):
continue
default_expr = ptrcls.get_default(ctx.env.schema)
if not default_expr:
if (
ptrcls.get_required(ctx.env.schema)
and pn != sn.UnqualName('__type__')
):
if ptrcls.is_property(ctx.env.schema):
# If the target is a sequence, there's no need
# for an explicit value.
ptrcls_target = ptrcls.get_target(ctx.env.schema)
assert ptrcls_target is not None
if ptrcls_target.issubclass(
ctx.env.schema,
ctx.env.schema.get(
'std::sequence',
type=s_objects.SubclassableObject)):
continue
vn = ptrcls.get_verbosename(
ctx.env.schema, with_parent=True)
raise errors.MissingRequiredError(
f'missing value for required {vn}')
else:
continue
ptrcls_sn = ptrcls.get_shortname(ctx.env.schema)
default_ql = qlast.ShapeElement(
expr=qlast.Path(
steps=[
qlast.Ptr(
ptr=qlast.ObjectRef(
name=ptrcls_sn.name,
module=ptrcls_sn.module,
),
),
],
),
compexpr=qlast.DetachedExpr(
expr=default_expr.qlast,
),
)
with ctx.newscope(fenced=True) as scopectx:
pointers.append(
_normalize_view_ptr_expr(
default_ql,
view_scls,
path_id=path_id,
path_id_namespace=path_id_namespace,
is_insert=is_insert,
is_update=is_update,
from_default=True,
view_rptr=view_rptr,
ctx=scopectx,
),
)
for ptrcls in pointers:
source: Union[s_types.Type, s_pointers.PointerLike]
if ptrcls.is_link_property(ctx.env.schema):
assert view_rptr is not None and view_rptr.ptrcls is not None
source = view_rptr.ptrcls
else:
source = view_scls
if is_defining_shape:
cinfo = ctx.source_map.get(ptrcls)
if cinfo is not None:
shape_op = cinfo.shape_op
else:
shape_op = qlast.ShapeOp.ASSIGN
elif ptrcls.get_computable(ctx.env.schema):
shape_op = qlast.ShapeOp.MATERIALIZE
else:
continue
ctx.env.view_shapes[source].append((ptrcls, shape_op))
if (view_rptr is not None and view_rptr.ptrcls is not None and
view_scls != stype):
ctx.env.schema = view_scls.set_field_value(
ctx.env.schema, 'rptr', view_rptr.ptrcls)
return view_scls