def _apply_fields_ast(
self,
schema: s_schema.Schema,
context: sd.CommandContext,
node: qlast.DDLOperation,
) -> None:
super()._apply_fields_ast(schema, context, node)
if isinstance(node, qlast.CreateConstraint):
params = []
for op in self.get_subcommands(type=s_func.ParameterCommand):
props = op.get_resolved_attributes(schema, context)
pname = s_func.Parameter.paramname_from_fullname(props['name'])
if pname == '__subject__':
continue
num = props['num']
default = props.get('default')
param = qlast.FuncParam(
name=pname,
type=utils.typeref_to_ast(schema, props['type']),
typemod=props['typemod'],
kind=props['kind'],
default=default.qlast if default is not None else None,
)
params.append((num, param))
params.sort(key=lambda e: e[0])
node.params = [p[1] for p in params]
def get_ast(self, schema: s_schema.Schema) -> qlast.FuncParam:
default = self.get_default(schema)
return qlast.FuncParam(
name=self.get_parameter_name(schema),
type=utils.typeref_to_ast(schema, self.get_type(schema)),
typemod=self.get_typemod(schema),
kind=self.get_kind(schema),
default=default.qlast if default else None,
)
def reduce_kwarg(self, *kids):
r"""%reduce OptParameterKind FuncDeclArgName COLON \
OptTypeQualifier FullTypeExpr OptDefault \
"""
self.val = qlast.FuncParam(kind=kids[0].val,
name=kids[1].val,
typemod=kids[3].val,
type=kids[4].val,
default=kids[5].val)
def _apply_fields_ast(self, schema, context, node):
super()._apply_fields_ast(schema, context, node)
params = []
for op in self.get_subcommands(type=ParameterCommand):
props = op.get_struct_properties(schema)
num = props['num']
default = props.get('default')
param = qlast.FuncParam(
name=Parameter.paramname_from_fullname(props['name']),
type=utils.typeref_to_ast(schema, props['type']),
typemod=props['typemod'],
kind=props['kind'],
default=default.qlast if default is not None else None,
)
params.append((num, param))
params.sort(key=lambda e: e[0])
node.params = [p[1] for p in params]
def _init_constraints(self, constraints):
for constraint, decl in constraints.items():
attrs = {a.name.name: a.value for a in decl.fields}
assert 'subject' not in attrs # TODO: Add proper validation
assert 'subjectexpr' not in attrs # TODO: Add proper validation
self._schema, params = s_func.FuncParameterList.from_ast(
self._schema,
decl,
self._mod_aliases,
func_fqname=constraint.get_name(self._schema),
prepend=[
qlast.FuncParam(
name='__subject__',
type=qlast.TypeName(maintype=qlast.AnyType(), ),
typemod=qltypes.TypeModifier.SINGLETON,
kind=qltypes.ParameterKind.POSITIONAL,
default=None,
),
],
)
for param in params.objects(self._schema):
p_kind = param.get_kind(self._schema)
if p_kind is qltypes.ParameterKind.NAMED_ONLY:
raise errors.InvalidConstraintDefinitionError(
'named only parameters are not allowed '
'in this context',
context=decl.context)
if param.get_default(self._schema) is not None:
raise errors.InvalidConstraintDefinitionError(
'constraints do not support parameters '
'with defaults',
context=decl.context)
anchors, _ = qlcompiler.get_param_anchors_for_callable(
params, self._schema)
expr = attrs.pop('expr', None)
if expr is not None:
self._schema = constraint.set_field_value(
self._schema,
'expr',
s_expr.Expression.compiled(
s_expr.Expression.from_ast(expr, self._schema,
self._mod_aliases),
schema=self._schema,
modaliases=self._mod_aliases,
anchors=anchors,
func_params=params,
allow_generic_type_output=True,
parent_object_type=type(constraint),
),
)
subjexpr = decl.subject
if subjexpr is not None:
self._schema = constraint.set_field_value(
self._schema,
'subjectexpr',
s_expr.Expression.compiled(
s_expr.Expression.from_ast(subjexpr, self._schema,
self._mod_aliases),
schema=self._schema,
modaliases=self._mod_aliases,
anchors=anchors,
func_params=params,
allow_generic_type_output=True,
parent_object_type=type(constraint),
),
)
self._schema = constraint.set_field_value(self._schema, 'params',
params)
