def compile_DeleteStmt(
stmt: irast.DeleteStmt, *,
ctx: context.CompilerContextLevel) -> pgast.Query:
parent_ctx = ctx
with parent_ctx.substmt() as ctx:
# Common DML bootstrap
wrapper, delete_cte, delete_rvar, range_cte = dml.init_dml_stmt(
stmt, pgast.DeleteStmt(), parent_ctx=parent_ctx, ctx=ctx)
assert range_cte is not None
ctx.toplevel_stmt.ctes.append(range_cte)
ctx.toplevel_stmt.ctes.append(delete_cte)
# Wrap up.
return dml.fini_dml_stmt(stmt, wrapper, delete_cte, delete_rvar,
parent_ctx=parent_ctx, ctx=ctx)
def process_link_update(
*, ir_stmt: irast.MutatingStmt, ir_set: irast.Set, props_only: bool,
is_insert: bool, wrapper: pgast.Query, dml_cte: pgast.CommonTableExpr,
iterator_cte: typing.Optional[pgast.CommonTableExpr],
ctx: context.CompilerContextLevel) -> pgast.CommonTableExpr:
"""Perform updates to a link relation as part of a DML statement.
:param ir_stmt:
IR of the statement.
:param ir_set:
IR of the INSERT/UPDATE body element.
:param props_only:
Whether this link update only touches link properties.
:param wrapper:
Top-level SQL query.
:param dml_cte:
CTE representing the SQL INSERT or UPDATE to the main
relation of the Object.
:param iterator_cte:
CTE representing the iterator range in the FOR clause of the
EdgeQL DML statement.
"""
toplevel = ctx.toplevel_stmt
rptr = ir_set.rptr
ptrref = rptr.ptrref
assert isinstance(ptrref, irast.PointerRef)
target_is_scalar = irtyputils.is_scalar(ptrref.dir_target)
path_id = ir_set.path_id
# The links in the dml class shape have been derived,
# but we must use the correct specialized link class for the
# base material type.
if ptrref.material_ptr is not None:
mptrref = ptrref.material_ptr
assert isinstance(mptrref, irast.PointerRef)
else:
mptrref = ptrref
target_rvar = relctx.range_for_ptrref(mptrref,
include_overlays=False,
only_self=True,
ctx=ctx)
assert isinstance(target_rvar, pgast.RelRangeVar)
assert isinstance(target_rvar.relation, pgast.Relation)
target_alias = target_rvar.alias.aliasname
target_tab_name = (target_rvar.relation.schemaname,
target_rvar.relation.name)
dml_cte_rvar = pgast.RelRangeVar(
relation=dml_cte,
alias=pgast.Alias(aliasname=ctx.env.aliases.get('m')))
col_data = {
'ptr_item_id':
pgast.TypeCast(arg=pgast.StringConstant(val=str(mptrref.id)),
type_name=pgast.TypeName(name=('uuid', ))),
'source':
pathctx.get_rvar_path_identity_var(dml_cte_rvar,
ir_stmt.subject.path_id,
env=ctx.env)
}
if not is_insert:
# Drop all previous link records for this source.
delcte = pgast.CommonTableExpr(query=pgast.DeleteStmt(
relation=target_rvar,
where_clause=astutils.new_binop(
lexpr=col_data['source'],
op='=',
rexpr=pgast.ColumnRef(name=[target_alias, 'source'])),
using_clause=[dml_cte_rvar],
returning_list=[
pgast.ResTarget(val=pgast.ColumnRef(
name=[target_alias, pgast.Star()]))
]),
name=ctx.env.aliases.get(hint='d'))
pathctx.put_path_value_rvar(delcte.query,
path_id.ptr_path(),
target_rvar,
env=ctx.env)
# Record the effect of this removal in the relation overlay
# context to ensure that references to the link in the result
# of this DML statement yield the expected results.
dml_stack = get_dml_stmt_stack(ir_stmt, ctx=ctx)
relctx.add_ptr_rel_overlay(ptrref,
'except',
delcte,
dml_stmts=dml_stack,
ctx=ctx)
toplevel.ctes.append(delcte)
# Turn the IR of the expression on the right side of :=
# into a subquery returning records for the link table.
data_cte, specified_cols = process_link_values(ir_stmt,
ir_set,
target_tab_name,
col_data,
dml_cte_rvar, [],
props_only,
target_is_scalar,
iterator_cte,
ctx=ctx)
toplevel.ctes.append(data_cte)
data_select = pgast.SelectStmt(
target_list=[
pgast.ResTarget(val=pgast.ColumnRef(
name=[data_cte.name, pgast.Star()]))
],
from_clause=[pgast.RelRangeVar(relation=data_cte)])
cols = [pgast.ColumnRef(name=[col]) for col in specified_cols]
if is_insert:
conflict_clause = None
else:
# Inserting rows into the link table may produce cardinality
# constraint violations, since the INSERT into the link table
# is executed in the snapshot where the above DELETE from
# the link table is not visible. Hence, we need to use
# the ON CONFLICT clause to resolve this.
conflict_cols = ['source', 'target', 'ptr_item_id']
conflict_inference = []
conflict_exc_row = []
for col in conflict_cols:
conflict_inference.append(pgast.ColumnRef(name=[col]))
conflict_exc_row.append(pgast.ColumnRef(name=['excluded', col]))
conflict_data = pgast.SelectStmt(
target_list=[
pgast.ResTarget(val=pgast.ColumnRef(
name=[data_cte.name, pgast.Star()]))
],
from_clause=[pgast.RelRangeVar(relation=data_cte)],
where_clause=astutils.new_binop(
lexpr=pgast.ImplicitRowExpr(args=conflict_inference),
rexpr=pgast.ImplicitRowExpr(args=conflict_exc_row),
op='='))
conflict_clause = pgast.OnConflictClause(
action='update',
infer=pgast.InferClause(index_elems=conflict_inference),
target_list=[
pgast.MultiAssignRef(columns=cols, source=conflict_data)
])
updcte = pgast.CommonTableExpr(
name=ctx.env.aliases.get(hint='i'),
query=pgast.InsertStmt(
relation=target_rvar,
select_stmt=data_select,
cols=cols,
on_conflict=conflict_clause,
returning_list=[
pgast.ResTarget(val=pgast.ColumnRef(name=[pgast.Star()]))
]))
pathctx.put_path_value_rvar(updcte.query,
path_id.ptr_path(),
target_rvar,
env=ctx.env)
# Record the effect of this insertion in the relation overlay
# context to ensure that references to the link in the result
# of this DML statement yield the expected results.
dml_stack = get_dml_stmt_stack(ir_stmt, ctx=ctx)
relctx.add_ptr_rel_overlay(ptrref,
'union',
updcte,
dml_stmts=dml_stack,
ctx=ctx)
toplevel.ctes.append(updcte)
return data_cte
def process_link_update(
*,
ir_stmt: irast.MutatingStmt,
ir_set: irast.Set,
props_only: bool,
is_insert: bool,
shape_op: qlast.ShapeOp = qlast.ShapeOp.ASSIGN,
source_typeref: irast.TypeRef,
wrapper: pgast.Query,
dml_cte: pgast.CommonTableExpr,
iterator_cte: Optional[pgast.CommonTableExpr],
ctx: context.CompilerContextLevel,
) -> pgast.CommonTableExpr:
"""Perform updates to a link relation as part of a DML statement.
:param ir_stmt:
IR of the statement.
:param ir_set:
IR of the INSERT/UPDATE body element.
:param props_only:
Whether this link update only touches link properties.
:param wrapper:
Top-level SQL query.
:param dml_cte:
CTE representing the SQL INSERT or UPDATE to the main
relation of the Object.
:param iterator_cte:
CTE representing the iterator range in the FOR clause of the
EdgeQL DML statement.
"""
toplevel = ctx.toplevel_stmt
rptr = ir_set.rptr
ptrref = rptr.ptrref
assert isinstance(ptrref, irast.PointerRef)
target_is_scalar = irtyputils.is_scalar(ir_set.typeref)
path_id = ir_set.path_id
# The links in the dml class shape have been derived,
# but we must use the correct specialized link class for the
# base material type.
if ptrref.material_ptr is not None:
mptrref = ptrref.material_ptr
else:
mptrref = ptrref
if mptrref.out_source.id != source_typeref.id:
for descendant in mptrref.descendants:
if descendant.out_source.id == source_typeref.id:
mptrref = descendant
break
else:
raise errors.InternalServerError(
'missing PointerRef descriptor for source typeref')
assert isinstance(mptrref, irast.PointerRef)
target_rvar = relctx.range_for_ptrref(mptrref,
for_mutation=True,
only_self=True,
ctx=ctx)
assert isinstance(target_rvar, pgast.RelRangeVar)
assert isinstance(target_rvar.relation, pgast.Relation)
target_alias = target_rvar.alias.aliasname
target_tab_name = (target_rvar.relation.schemaname,
target_rvar.relation.name)
dml_cte_rvar = pgast.RelRangeVar(
relation=dml_cte,
alias=pgast.Alias(aliasname=ctx.env.aliases.get('m')))
col_data = {
'ptr_item_id':
pgast.TypeCast(arg=pgast.StringConstant(val=str(mptrref.id)),
type_name=pgast.TypeName(name=('uuid', ))),
'source':
pathctx.get_rvar_path_identity_var(dml_cte_rvar,
ir_stmt.subject.path_id,
env=ctx.env)
}
# Turn the IR of the expression on the right side of :=
# into a subquery returning records for the link table.
data_cte, specified_cols = process_link_values(
ir_stmt=ir_stmt,
ir_expr=ir_set,
target_tab=target_tab_name,
col_data=col_data,
dml_rvar=dml_cte_rvar,
sources=[],
props_only=props_only,
target_is_scalar=target_is_scalar,
iterator_cte=iterator_cte,
ctx=ctx,
)
toplevel.ctes.append(data_cte)
delqry: Optional[pgast.DeleteStmt]
data_select = pgast.SelectStmt(
target_list=[
pgast.ResTarget(val=pgast.ColumnRef(
name=[data_cte.name, pgast.Star()]), ),
],
from_clause=[
pgast.RelRangeVar(relation=data_cte),
],
)
if not is_insert and shape_op is not qlast.ShapeOp.APPEND:
if shape_op is qlast.ShapeOp.SUBTRACT:
data_rvar = relctx.rvar_for_rel(data_select, ctx=ctx)
# Drop requested link records.
delqry = pgast.DeleteStmt(
relation=target_rvar,
where_clause=astutils.new_binop(
lexpr=astutils.new_binop(
lexpr=col_data['source'],
op='=',
rexpr=pgast.ColumnRef(name=[target_alias, 'source'], ),
),
op='AND',
rexpr=astutils.new_binop(
lexpr=pgast.ColumnRef(name=[target_alias, 'target'], ),
op='=',
rexpr=pgast.ColumnRef(
name=[data_rvar.alias.aliasname, 'target'], ),
),
),
using_clause=[
dml_cte_rvar,
data_rvar,
],
returning_list=[
pgast.ResTarget(val=pgast.ColumnRef(
name=[target_alias, pgast.Star()], ), )
])
else:
# Drop all previous link records for this source.
delqry = pgast.DeleteStmt(
relation=target_rvar,
where_clause=astutils.new_binop(
lexpr=col_data['source'],
op='=',
rexpr=pgast.ColumnRef(name=[target_alias, 'source'], ),
),
using_clause=[dml_cte_rvar],
returning_list=[
pgast.ResTarget(val=pgast.ColumnRef(
name=[target_alias, pgast.Star()], ), )
])
delcte = pgast.CommonTableExpr(
name=ctx.env.aliases.get(hint='d'),
query=delqry,
)
pathctx.put_path_value_rvar(delcte.query,
path_id.ptr_path(),
target_rvar,
env=ctx.env)
# Record the effect of this removal in the relation overlay
# context to ensure that references to the link in the result
# of this DML statement yield the expected results.
dml_stack = get_dml_stmt_stack(ir_stmt, ctx=ctx)
relctx.add_ptr_rel_overlay(ptrref,
'except',
delcte,
dml_stmts=dml_stack,
ctx=ctx)
toplevel.ctes.append(delcte)
else:
delqry = None
if shape_op is qlast.ShapeOp.SUBTRACT:
return data_cte
cols = [pgast.ColumnRef(name=[col]) for col in specified_cols]
conflict_cols = ['source', 'target', 'ptr_item_id']
if is_insert:
conflict_clause = None
elif len(cols) == len(conflict_cols) and delqry is not None:
# There are no link properties, so we can optimize the
# link replacement operation by omitting the overlapping
# link rows from deletion.
filter_select = pgast.SelectStmt(
target_list=[
pgast.ResTarget(val=pgast.ColumnRef(name=['source']), ),
pgast.ResTarget(val=pgast.ColumnRef(name=['target']), ),
],
from_clause=[pgast.RelRangeVar(relation=data_cte)],
)
delqry.where_clause = astutils.extend_binop(
delqry.where_clause,
astutils.new_binop(
lexpr=pgast.ImplicitRowExpr(args=[
pgast.ColumnRef(name=['source']),
pgast.ColumnRef(name=['target']),
], ),
rexpr=pgast.SubLink(
type=pgast.SubLinkType.ALL,
expr=filter_select,
),
op='!=',
))
conflict_clause = pgast.OnConflictClause(
action='nothing',
infer=pgast.InferClause(index_elems=[
pgast.ColumnRef(name=[col]) for col in conflict_cols
]),
)
else:
# Inserting rows into the link table may produce cardinality
# constraint violations, since the INSERT into the link table
# is executed in the snapshot where the above DELETE from
# the link table is not visible. Hence, we need to use
# the ON CONFLICT clause to resolve this.
conflict_inference = []
conflict_exc_row = []
for col in conflict_cols:
conflict_inference.append(pgast.ColumnRef(name=[col]))
conflict_exc_row.append(pgast.ColumnRef(name=['excluded', col]))
conflict_data = pgast.SelectStmt(
target_list=[
pgast.ResTarget(val=pgast.ColumnRef(
name=[data_cte.name, pgast.Star()]))
],
from_clause=[pgast.RelRangeVar(relation=data_cte)],
where_clause=astutils.new_binop(
lexpr=pgast.ImplicitRowExpr(args=conflict_inference),
rexpr=pgast.ImplicitRowExpr(args=conflict_exc_row),
op='='))
conflict_clause = pgast.OnConflictClause(
action='update',
infer=pgast.InferClause(index_elems=conflict_inference),
target_list=[
pgast.MultiAssignRef(columns=cols, source=conflict_data)
])
updcte = pgast.CommonTableExpr(
name=ctx.env.aliases.get(hint='i'),
query=pgast.InsertStmt(
relation=target_rvar,
select_stmt=data_select,
cols=cols,
on_conflict=conflict_clause,
returning_list=[
pgast.ResTarget(val=pgast.ColumnRef(name=[pgast.Star()]))
]))
pathctx.put_path_value_rvar(updcte.query,
path_id.ptr_path(),
target_rvar,
env=ctx.env)
# Record the effect of this insertion in the relation overlay
# context to ensure that references to the link in the result
# of this DML statement yield the expected results.
dml_stack = get_dml_stmt_stack(ir_stmt, ctx=ctx)
relctx.add_ptr_rel_overlay(ptrref,
'union',
updcte,
dml_stmts=dml_stack,
ctx=ctx)
toplevel.ctes.append(updcte)
return data_cte
def gen_dml_cte(
ir_stmt: irast.MutatingStmt,
*,
range_rvar: Optional[pgast.RelRangeVar],
typeref: irast.TypeRef,
ctx: context.CompilerContextLevel,
) -> Tuple[pgast.CommonTableExpr, pgast.PathRangeVar]:
target_ir_set = ir_stmt.subject
target_path_id = target_ir_set.path_id
dml_stmt: pgast.Query
if isinstance(ir_stmt, irast.InsertStmt):
dml_stmt = pgast.InsertStmt()
elif isinstance(ir_stmt, irast.UpdateStmt):
dml_stmt = pgast.UpdateStmt()
elif isinstance(ir_stmt, irast.DeleteStmt):
dml_stmt = pgast.DeleteStmt()
else:
raise AssertionError(f'unexpected DML IR: {ir_stmt!r}')
dml_stmt.relation = relctx.range_for_typeref(
typeref,
target_path_id,
for_mutation=True,
common_parent=True,
ctx=ctx,
)
pathctx.put_path_value_rvar(dml_stmt,
target_path_id,
dml_stmt.relation,
env=ctx.env)
pathctx.put_path_source_rvar(dml_stmt,
target_path_id,
dml_stmt.relation,
env=ctx.env)
pathctx.put_path_bond(dml_stmt, target_path_id)
dml_cte = pgast.CommonTableExpr(query=dml_stmt,
name=ctx.env.aliases.get(hint='m'))
if range_rvar is not None:
relctx.pull_path_namespace(target=dml_stmt, source=range_rvar, ctx=ctx)
# Auxiliary relations are always joined via the WHERE
# clause due to the structure of the UPDATE/DELETE SQL statements.
dml_stmt.where_clause = astutils.new_binop(
lexpr=pgast.ColumnRef(
name=[dml_stmt.relation.alias.aliasname, 'id']),
op='=',
rexpr=pathctx.get_rvar_path_identity_var(range_rvar,
target_ir_set.path_id,
env=ctx.env))
# UPDATE has "FROM", while DELETE has "USING".
if isinstance(dml_stmt, pgast.UpdateStmt):
dml_stmt.from_clause.append(range_rvar)
elif isinstance(dml_stmt, pgast.DeleteStmt):
dml_stmt.using_clause.append(range_rvar)
# Due to the fact that DML statements are structured
# as a flat list of CTEs instead of nested range vars,
# the top level path scope must be empty. The necessary
# range vars will be injected explicitly in all rels that
# need them.
ctx.path_scope.clear()
pathctx.put_path_value_rvar(dml_stmt,
target_path_id,
dml_stmt.relation,
env=ctx.env)
pathctx.put_path_source_rvar(dml_stmt,
target_path_id,
dml_stmt.relation,
env=ctx.env)
dml_rvar = relctx.rvar_for_rel(dml_cte, typeref=typeref, ctx=ctx)
return dml_cte, dml_rvar
def compile_ConfigReset(op: irast.ConfigReset, *,
ctx: context.CompilerContextLevel) -> pgast.Query:
if op.selector is None:
# Scalar reset
result_row = pgast.RowExpr(args=[
pgast.StringConstant(val='RESET'),
pgast.StringConstant(val='SYSTEM' if op.system else 'SESSION'),
pgast.StringConstant(val=op.name),
pgast.NullConstant(),
])
rvar = None
else:
selector = dispatch.compile(op.selector, ctx=ctx)
assert isinstance(selector, pgast.SelectStmt), \
"expected ast.SelectStmt"
target = selector.target_list[0]
if not target.name:
target = selector.target_list[0] = pgast.ResTarget(
name=ctx.env.aliases.get('res'),
val=target.val,
)
rvar = relctx.rvar_for_rel(selector, ctx=ctx)
result_row = pgast.RowExpr(args=[
pgast.StringConstant(val='REM'),
pgast.StringConstant(val='SYSTEM' if op.system else 'SESSION'),
pgast.StringConstant(val=op.name),
astutils.get_column(rvar, target.name),
])
result = pgast.FuncCall(
name=('jsonb_build_array', ),
args=result_row.args,
null_safe=True,
ser_safe=True,
)
stmt: pgast.Query
if not op.system:
stmt = pgast.DeleteStmt(
relation=pgast.RelRangeVar(relation=pgast.Relation(
name='_edgecon_state', ), ),
where_clause=astutils.new_binop(
lexpr=astutils.new_binop(
lexpr=pgast.ColumnRef(name=['name']),
rexpr=pgast.StringConstant(val=op.name),
op='=',
),
rexpr=astutils.new_binop(
lexpr=pgast.ColumnRef(name=['type']),
rexpr=pgast.StringConstant(val='C'),
op='=',
),
op='AND',
))
else:
stmt = pgast.SelectStmt(target_list=[
pgast.ResTarget(val=result, ),
], )
if rvar is not None:
stmt.from_clause = [rvar]
return stmt
def compile_ConfigReset(
op: irast.ConfigReset,
*,
ctx: context.CompilerContextLevel,
) -> pgast.BaseExpr:
stmt: pgast.BaseExpr
if op.scope is qltypes.ConfigScope.SYSTEM and op.backend_setting:
stmt = pgast.AlterSystem(
name=op.backend_setting,
value=None,
)
elif op.scope is qltypes.ConfigScope.DATABASE and op.backend_setting:
fcall = pgast.FuncCall(
name=('edgedb', '_alter_current_database_set'),
args=[
pgast.StringConstant(val=op.backend_setting),
pgast.NullConstant(),
],
)
stmt = output.wrap_script_stmt(
pgast.SelectStmt(target_list=[pgast.ResTarget(val=fcall)]),
suppress_all_output=True,
env=ctx.env,
)
elif op.scope is qltypes.ConfigScope.SESSION and op.backend_setting:
fcall = pgast.FuncCall(
name=('pg_catalog', 'set_config'),
args=[
pgast.StringConstant(val=op.backend_setting),
pgast.NullConstant(),
pgast.BooleanConstant(val='false'),
],
)
stmt = output.wrap_script_stmt(
pgast.SelectStmt(target_list=[pgast.ResTarget(val=fcall)]),
suppress_all_output=True,
env=ctx.env,
)
elif op.scope is qltypes.ConfigScope.SYSTEM:
if op.selector is None:
# Scalar reset
result_row = pgast.RowExpr(
args=[
pgast.StringConstant(val='RESET'),
pgast.StringConstant(val=str(op.scope)),
pgast.StringConstant(val=op.name),
pgast.NullConstant(),
]
)
rvar = None
else:
with context.output_format(ctx, context.OutputFormat.JSONB):
selector = dispatch.compile(op.selector, ctx=ctx)
assert isinstance(selector, pgast.SelectStmt), \
"expected ast.SelectStmt"
target = selector.target_list[0]
if not target.name:
target = selector.target_list[0] = pgast.ResTarget(
name=ctx.env.aliases.get('res'),
val=target.val,
)
rvar = relctx.rvar_for_rel(selector, ctx=ctx)
result_row = pgast.RowExpr(
args=[
pgast.StringConstant(val='REM'),
pgast.StringConstant(val=str(op.scope)),
pgast.StringConstant(val=op.name),
astutils.get_column(rvar, target.name),
]
)
result = pgast.FuncCall(
name=('jsonb_build_array',),
args=result_row.args,
null_safe=True,
ser_safe=True,
)
stmt = pgast.SelectStmt(
target_list=[
pgast.ResTarget(
val=result,
),
],
)
if rvar is not None:
stmt.from_clause = [rvar]
elif op.scope is qltypes.ConfigScope.DATABASE:
stmt = pgast.DeleteStmt(
relation=pgast.RelRangeVar(
relation=pgast.Relation(
name='_db_config',
schemaname='edgedb',
),
),
where_clause=astutils.new_binop(
lexpr=pgast.ColumnRef(name=['name']),
rexpr=pgast.StringConstant(val=op.name),
op='=',
),
)
elif op.scope is qltypes.ConfigScope.SESSION:
stmt = pgast.DeleteStmt(
relation=pgast.RelRangeVar(
relation=pgast.Relation(
name='_edgecon_state',
),
),
where_clause=astutils.new_binop(
lexpr=astutils.new_binop(
lexpr=pgast.ColumnRef(name=['name']),
rexpr=pgast.StringConstant(val=op.name),
op='=',
),
rexpr=astutils.new_binop(
lexpr=pgast.ColumnRef(name=['type']),
rexpr=pgast.StringConstant(val='C'),
op='=',
),
op='AND',
)
)
else:
raise AssertionError(f'unexpected configuration scope: {op.scope}')
return stmt
