def get_field_template(self, name, *, parent=None, has_shape=False):
eql = shape = filterable = None
if self.dummy:
return eql, shape, filterable
if name == '__typename':
eql = parse_fragment(
f'''graphql::short_name(
{codegen.generate_source(parent)}.__type__.name)''')
elif has_shape:
eql = filterable = parse_fragment(
f'''SELECT {codegen.generate_source(parent)}.
{codegen.generate_source(qlast.ObjectRef(name=name))}
{{ xxx }}
''')
filterable = eql
shape = filterable.result
else:
eql = filterable = parse_fragment(
f'''SELECT {codegen.generate_source(parent)}.
{codegen.generate_source(qlast.ObjectRef(name=name))}
''')
return eql, shape, filterable
def get_template(self):
'''Provide an EQL AST template to be filled.
Return the overall ast, a reference to where the shape element
with placeholder is, and a reference to the element which may
be filtered.
'''
if self.dummy:
return parse_fragment(f'''<json>"xxx"'''), None, None
eql = parse_fragment(f'''
SELECT {self.edb_base_name} {{
xxx
}}
''')
filterable = eql
shape = filterable.result
return eql, shape, filterable
def compile_fragment_to_ir(expr,
schema,
*,
anchors=None,
location=None,
modaliases=None):
"""Compile given EdgeQL expression fragment into EdgeDB IR."""
tree = ql_parser.parse_fragment(expr)
return compile_ast_fragment_to_ir(tree,
schema,
anchors=anchors,
location=location,
modaliases=modaliases)
def rewrite_refs(expr, callback):
"""Rewrite class references in EdgeQL expression."""
tree = qlparser.parse_fragment(expr)
def _cb(node):
if isinstance(node, qlast.ObjectRef):
name = sn.Name(name=node.name, module=node.module)
upd = callback(name)
if name != upd:
node.name = upd.name
node.module = upd.module
ast.find_children(tree, _cb)
return qlcodegen.generate_source(tree, pretty=False)
def compile_FunctionCall(
expr: qlast.Base, *, ctx: context.ContextLevel) -> irast.Base:
with ctx.new() as fctx:
if isinstance(expr.func, str):
funcname = expr.func
else:
funcname = sn.Name(expr.func[1], expr.func[0])
funcs = fctx.schema.get_functions(
funcname, module_aliases=fctx.modaliases)
if funcs is None:
raise errors.EdgeQLError(
f'could not resolve function name {funcname}',
context=expr.context)
fctx.in_func_call = True
args, kwargs, arg_types = process_func_args(expr, funcname, ctx=fctx)
fatal_array_check = len(funcs) == 1
for funcobj in funcs:
if check_function(expr, funcname, funcobj, arg_types,
fatal_array_check=fatal_array_check):
break
else:
raise errors.EdgeQLError(
f'could not find a function variant {funcname}',
context=expr.context)
fixup_param_scope(funcobj, args, kwargs, ctx=fctx)
node = irast.FunctionCall(func=funcobj, args=args, kwargs=kwargs)
if funcobj.initial_value is not None:
rtype = irutils.infer_type(node, fctx.schema)
iv_ql = qlast.TypeCast(
expr=qlparser.parse_fragment(funcobj.initial_value),
type=typegen.type_to_ql_typeref(rtype)
)
node.initial_value = dispatch.compile(iv_ql, ctx=fctx)
ir_set = setgen.ensure_set(node, ctx=ctx)
return ir_set
def compile_FunctionCall(expr: qlast.Base, *,
ctx: context.ContextLevel) -> irast.Base:
env = ctx.env
if isinstance(expr.func, str):
if ctx.func is not None:
ctx_func_params = ctx.func.get_params(env.schema)
if ctx_func_params.get_by_name(env.schema, expr.func):
raise errors.QueryError(
f'parameter `{expr.func}` is not callable',
context=expr.context)
funcname = expr.func
else:
funcname = sn.Name(expr.func[1], expr.func[0])
funcs = env.schema.get_functions(funcname, module_aliases=ctx.modaliases)
if funcs is None:
raise errors.QueryError(f'could not resolve function name {funcname}',
context=expr.context)
args, kwargs = compile_call_args(expr, funcname, ctx=ctx)
matched = polyres.find_callable(funcs, args=args, kwargs=kwargs, ctx=ctx)
if not matched:
raise errors.QueryError(
f'could not find a function variant {funcname}',
context=expr.context)
elif len(matched) > 1:
raise errors.QueryError(f'function {funcname} is not unique',
context=expr.context)
else:
matched_call = matched[0]
args, params_typemods = finalize_args(matched_call, ctx=ctx)
matched_func_params = matched_call.func.get_params(env.schema)
variadic_param = matched_func_params.find_variadic(env.schema)
variadic_param_type = None
if variadic_param is not None:
variadic_param_type = variadic_param.get_type(env.schema)
matched_func_ret_type = matched_call.func.get_return_type(env.schema)
is_polymorphic = (any(
p.get_type(env.schema).is_polymorphic(env.schema)
for p in matched_func_params.objects(env.schema))
and matched_func_ret_type.is_polymorphic(env.schema))
matched_func_initial_value = matched_call.func.get_initial_value(
env.schema)
func = matched_call.func
node = irast.FunctionCall(
args=args,
func_shortname=func.get_shortname(env.schema),
func_polymorphic=is_polymorphic,
func_sql_function=func.get_from_function(env.schema),
force_return_cast=func.get_force_return_cast(env.schema),
params_typemods=params_typemods,
context=expr.context,
stype=matched_call.return_type,
typemod=matched_call.func.get_return_typemod(env.schema),
has_empty_variadic=matched_call.has_empty_variadic,
variadic_param_type=variadic_param_type,
)
if matched_func_initial_value is not None:
rtype = inference.infer_type(node, env=ctx.env)
iv_ql = qlast.TypeCast(
expr=qlparser.parse_fragment(matched_func_initial_value),
type=typegen.type_to_ql_typeref(rtype, ctx=ctx))
node.func_initial_value = dispatch.compile(iv_ql, ctx=ctx)
return setgen.ensure_set(node, typehint=matched_call.return_type, ctx=ctx)
def get_ql_default(self, schema):
from edb.lang.edgeql import parser as ql_parser
return ql_parser.parse_fragment(self.get_default(schema))