def ensure_qlstmt(expr):
if not isinstance(expr, qlast.Statement):
expr = qlast.SelectQuery(
result=expr,
implicit=True,
)
return expr
def _compile_and_apply_delta_command(self, ctx: CompileContext,
cmd) -> dbstate.BaseQuery:
current_tx = ctx.state.current_tx()
schema = current_tx.get_schema()
context = self._new_delta_context(ctx)
if isinstance(cmd, s_deltas.CreateDelta):
delta = None
else:
delta = schema.get(cmd.classname)
with context(s_deltas.DeltaCommandContext(schema, cmd, delta)):
if isinstance(cmd, s_deltas.CommitDelta):
ddl_plan = s_delta.DeltaRoot()
ddl_plan.update(delta.get_commands(schema))
return self._compile_and_apply_ddl_command(ctx, ddl_plan)
elif isinstance(cmd, s_deltas.GetDelta):
delta_ql = s_ddl.ddl_text_from_delta(schema, delta)
query_ql = qlast.SelectQuery(result=qlast.StringConstant(
quote="'", value=ql_quote.escape_string(delta_ql)))
return self._compile_ql_query(ctx, query_ql)
elif isinstance(cmd, s_deltas.CreateDelta):
schema, _ = cmd.apply(schema, context)
current_tx.update_schema(schema)
return dbstate.DDLQuery(sql=b'')
else:
raise RuntimeError(f'unexpected delta command: {cmd!r}')
def _encode_default(self, context, node, op):
if op.new_value:
expr = op.new_value
if not isinstance(expr, sexpr.ExpressionText):
expr_t = qlast.SelectQuery(result=qlast.Constant(value=expr))
expr = edgeql.generate_source(expr_t, pretty=False)
op.new_value = sexpr.ExpressionText(expr)
super()._apply_field_ast(context, node, op)
def reduce_Select(self, *kids):
r"%reduce SELECT OptionallyAliasedExpr \
OptFilterClause OptSortClause OptSelectLimit"
self.val = qlast.SelectQuery(
result=kids[1].val.expr,
result_alias=kids[1].val.alias,
where=kids[2].val,
orderby=kids[3].val,
offset=kids[4].val[0],
limit=kids[4].val[1],
)
def decompile_ir(ir_tree,
inline_anchors=False,
return_statement=False,
*,
schema):
decompiler = IRDecompiler()
qltree = decompiler.transform(ir_tree,
inline_anchors=inline_anchors,
schema=schema)
if return_statement and not isinstance(qltree, qlast.Statement):
qltree = qlast.SelectQuery(result=qltree)
return qltree
def _compile_view_expr(cls, expr, classname, schema, context):
from edb.lang.edgeql import compiler as qlcompiler
ir = context.get_cached((expr, classname))
if ir is None:
if not isinstance(expr, qlast.Statement):
expr = qlast.SelectQuery(result=expr)
ir = qlcompiler.compile_ast_to_ir(
expr,
schema,
derived_target_module=classname.module,
result_view_name=classname)
context.cache_value((expr, classname), ir)
return ir
def visit_SelectStmt(self, node):
result = qlast.SelectQuery()
if node.where is not None:
result.where = self.visit(node.where)
if node.orderby:
result.orderby = self.visit(node.orderby)
if node.offset is not None:
result.offset = self.visit(node.offset)
if node.limit is not None:
result.limit = self.visit(node.limit)
if node.result is not None:
result.result = self.visit(node.result)
return result
def _visit_query(self, node):
# populate input variables with defaults, where applicable
if node.variables:
self.visit(node.variables)
# base Query needs to be configured specially
base = self._context.gqlcore.get('Query')
# special treatment of the selection_set, different from inner
# recursion
query = qlast.SelectQuery(result=qlast.Shape(expr=qlast.Path(
steps=[qlast.ObjectRef(name='Query', module='stdgraphql')]),
elements=[]), )
self._context.fields.append({})
self._context.path.append([Step(None, base)])
query.result.elements = self.visit(node.selection_set)
self._context.fields.pop()
self._context.path.pop()
return query
