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, )