def get_scope_stmt(path_id: irast.PathId, *,
ctx: context.CompilerContextLevel) -> pgast.Query:
stmt = ctx.path_scope.get(path_id)
if stmt is None and path_id.is_ptr_path():
stmt = ctx.path_scope.get(path_id.tgt_path())
if stmt is None:
raise LookupError(f'cannot find scope statement for {path_id}')
return stmt
def maybe_get_scope_stmt(
path_id: irast.PathId,
*,
ctx: context.CompilerContextLevel,
) -> Optional[pgast.SelectStmt]:
stmt = ctx.path_scope.get(path_id)
if stmt is None and path_id.is_ptr_path():
stmt = ctx.path_scope.get(path_id.tgt_path())
return stmt
def new_external_rvar(
*,
rel_name: Tuple[str, ...],
path_id: irast.PathId,
outputs: Mapping[Tuple[irast.PathId, Tuple[str, ...]], str],
) -> pgast.RelRangeVar:
"""Construct a ``RangeVar`` instance given a relation name and a path id.
Given an optionally-qualified relation name *rel_name* and a *path_id*,
return a ``RangeVar`` instance over the specified relation that is
then assumed to represent the *path_id* binding.
This is useful in situations where it is necessary to "prime" the compiler
with a list of external relations that exist in a larger SQL expression
that _this_ expression is being embedded into.
The *outputs* mapping optionally specifies a set of outputs in the
resulting range var as a ``(path_id, tuple-of-aspects): attribute name``
mapping.
"""
if len(rel_name) == 1:
table_name = rel_name[0]
schema_name = None
elif len(rel_name) == 2:
schema_name, table_name = rel_name
else:
raise AssertionError(f'unexpected rvar name: {rel_name}')
rel = pgast.Relation(
name=table_name,
schemaname=schema_name,
path_id=path_id,
)
alias = pgast.Alias(aliasname=table_name)
if not path_id.is_ptr_path():
rvar = pgast.RelRangeVar(
relation=rel, typeref=path_id.target, alias=alias)
else:
rvar = pgast.RelRangeVar(
relation=rel, alias=alias)
for (output_pid, output_aspects), colname in outputs.items():
var = pgast.ColumnRef(name=[colname])
for aspect in output_aspects:
rel.path_outputs[output_pid, aspect] = var
return rvar
