def scan_check_ctes(
stmt: pgast.Query,
check_ctes: List[pgast.CommonTableExpr],
*,
ctx: context.CompilerContextLevel,
) -> None:
if not check_ctes:
return
# Scan all of the check CTEs to enforce constraints that are
# checked as explicit queries and not Postgres constraints or
# triggers.
# To make sure that Postgres can't optimize the checks away, we
# reference them in the where clause of an UPDATE to a dummy
# table.
# Add a big random number, so that different queries should try to
# access different "rows" of the table, in case that matters.
base_int = random.randint(0, (1 << 60) - 1)
val: pgast.BaseExpr = pgast.NumericConstant(val=str(base_int))
for check_cte in check_ctes:
# We want the CTE to be MATERIALIZED, because otherwise
# Postgres might not fully evaluate all its columns when
# scanning it.
check_cte.materialized = True
check = pgast.SelectStmt(
target_list=[
pgast.ResTarget(val=pgast.FuncCall(name=('count', ),
args=[pgast.Star()]), )
],
from_clause=[
relctx.rvar_for_rel(check_cte, ctx=ctx),
],
)
val = pgast.Expr(kind=pgast.ExprKind.OP,
name='+',
lexpr=val,
rexpr=check)
update_query = pgast.UpdateStmt(
targets=[
pgast.UpdateTarget(name='flag',
val=pgast.BooleanConstant(val='true'))
],
relation=pgast.RelRangeVar(
relation=pgast.Relation(schemaname='edgedb', name='_dml_dummy')),
where_clause=pgast.Expr(
kind=pgast.ExprKind.OP,
name='=',
lexpr=pgast.ColumnRef(name=['id']),
rexpr=val,
))
stmt.append_cte(
pgast.CommonTableExpr(query=update_query,
name=ctx.env.aliases.get(hint='check_scan')))
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
