def simple_stmt_eq(lhs: irast.Base, rhs: irast.Base,
schema: s_schema.Schema) -> bool:
if (isinstance(lhs, irast.BaseConstant)
and isinstance(rhs, irast.BaseConstant)
and (ireval.evaluate_to_python_val(lhs, schema)
== ireval.evaluate_to_python_val(rhs, schema))):
return True
elif (isinstance(lhs, irast.Parameter)
and isinstance(rhs, irast.Parameter) and lhs.name == rhs.name):
return True
else:
return False
def evaluate_ast_to_python_val(
tree: qlast.Base,
schema: s_schema.Schema,
*,
modaliases: Optional[Mapping[Optional[str], str]] = None,
) -> Any:
"""Evaluate the given EdgeQL AST as a constant expression.
Args:
tree:
EdgeQL AST.
schema:
Schema instance. Must contain definitions for objects
referenced by AST *tree*.
modaliases:
Module name resolution table. Useful when this EdgeQL
expression is part of some other construct, such as a
DDL statement.
Returns:
The result of the evaluation as a Python value.
Raises:
If the expression is not constant, or is otherwise not supported by
the const evaluator, the function will raise
:exc:`ir.staeval.UnsupportedExpressionError`.
"""
ir = compile_ast_fragment_to_ir(tree, schema, modaliases=modaliases)
return ireval.evaluate_to_python_val(ir.expr, schema=ir.schema)
def compile_ConfigSet(
expr: qlast.ConfigSet,
*,
ctx: context.ContextLevel,
) -> irast.Set:
info = _validate_op(expr, ctx=ctx)
param_val = dispatch.compile(expr.expr, ctx=ctx)
param_type = info.param_type
val_type = inference.infer_type(param_val, ctx.env)
compatible = s_types.is_type_compatible(val_type,
param_type,
schema=ctx.env.schema)
if not compatible:
if not val_type.assignment_castable_to(param_type, ctx.env.schema):
raise errors.ConfigurationError(
f'invalid setting value type for {info.param_name}: '
f'{val_type.get_displayname(ctx.env.schema)!r} '
f'(expecting {param_type.get_displayname(ctx.env.schema)!r})')
else:
param_val = casts.compile_cast(param_val,
param_type,
srcctx=None,
ctx=ctx)
try:
if expr.scope != qltypes.ConfigScope.GLOBAL:
val = ireval.evaluate_to_python_val(param_val,
schema=ctx.env.schema)
else:
val = None
except ireval.UnsupportedExpressionError as e:
raise errors.QueryError(
f'non-constant expression in CONFIGURE {expr.scope} SET',
context=expr.expr.context) from e
else:
if isinstance(val, statypes.ScalarType) and info.backend_setting:
backend_expr = dispatch.compile(
qlast.StringConstant.from_python(val.to_backend_str()),
ctx=ctx,
)
else:
backend_expr = None
config_set = irast.ConfigSet(
name=info.param_name,
cardinality=info.cardinality,
required=info.required,
scope=expr.scope,
requires_restart=info.requires_restart,
backend_setting=info.backend_setting,
context=expr.context,
expr=param_val,
backend_expr=backend_expr,
)
return setgen.ensure_set(config_set, ctx=ctx)
def evaluate_ast_to_python_val(tree, schema, *, modaliases=None) -> object:
ir = compile_ast_fragment_to_ir(tree, schema, modaliases=modaliases)
return ireval.evaluate_to_python_val(ir.expr, schema=ir.schema)
def _compile_ql_config_op(self, ctx: CompileContext, ql: qlast.Base):
current_tx = ctx.state.current_tx()
schema = current_tx.get_schema()
modaliases = ctx.state.current_tx().get_modaliases()
session_config = ctx.state.current_tx().get_session_config()
if ql.system and not current_tx.is_implicit():
raise errors.QueryError('CONFIGURE SYSTEM cannot be executed in a '
'transaction block')
ir = ql_compiler.compile_ast_to_ir(
ql,
schema=schema,
modaliases=modaliases,
)
is_backend_setting = bool(getattr(ir, 'backend_setting', None))
requires_restart = bool(getattr(ir, 'requires_restart', False))
if is_backend_setting:
if isinstance(ql, qlast.ConfigReset):
val = None
else:
# Postgres is fine with all setting types to be passed
# as strings.
value = ireval.evaluate_to_python_val(ir.expr, schema=schema)
val = pg_ast.StringConstant(val=str(value))
if ir.system:
sql_ast = pg_ast.AlterSystem(
name=ir.backend_setting,
value=val,
)
else:
sql_ast = pg_ast.Set(
name=ir.backend_setting,
value=val,
)
sql_text = pg_codegen.generate_source(sql_ast) + ';'
sql = (sql_text.encode(), )
else:
sql_text, _ = pg_compiler.compile_ir_to_sql(
ir,
pretty=debug.flags.edgeql_compile,
output_format=pg_compiler.OutputFormat.JSONB)
sql = (sql_text.encode(), )
if not ql.system:
config_op = ireval.evaluate_to_config_op(ir, schema=schema)
session_config = config_op.apply(config.get_settings(),
session_config)
ctx.state.current_tx().update_session_config(session_config)
else:
config_op = None
return dbstate.SessionStateQuery(
sql=sql,
is_backend_setting=is_backend_setting,
is_system_setting=ql.system,
requires_restart=requires_restart,
config_op=config_op,
)