def apply_volatility_ref(stmt: pgast.SelectStmt, *, ctx: context.CompilerContextLevel) -> None: for ref in ctx.volatility_ref: # Apply the volatility reference. # See the comment in process_set_as_subquery(). stmt.where_clause = astutils.extend_binop( stmt.where_clause, pgast.NullTest( arg=ref(), negated=True, ))
def anti_join( lhs: pgast.SelectStmt, rhs: pgast.SelectStmt, path_id: Optional[irast.PathId], *, ctx: context.CompilerContextLevel, ) -> None: """Filter elements out of the LHS that appear on the RHS""" if path_id: # grab the identity from the LHS and do an # anti-join against the RHS. src_ref = pathctx.get_path_identity_var(lhs, path_id=path_id, env=ctx.env) pathctx.get_path_identity_output(rhs, path_id=path_id, env=ctx.env) cond_expr: pgast.BaseExpr = astutils.new_binop(src_ref, rhs, 'NOT IN') else: # No path we care about. Just check existance. cond_expr = pgast.SubLink(type=pgast.SubLinkType.NOT_EXISTS, expr=rhs) lhs.where_clause = astutils.extend_binop(lhs.where_clause, cond_expr)
def semi_join(stmt: pgast.SelectStmt, ir_set: irast.Set, src_rvar: pgast.PathRangeVar, *, ctx: context.CompilerContextLevel) -> pgast.PathRangeVar: """Join an IR Set using semi-join.""" rptr = ir_set.rptr assert rptr is not None # Target set range. set_rvar = new_root_rvar(ir_set, ctx=ctx) ptrref = rptr.ptrref ptr_info = pg_types.get_ptrref_storage_info(ptrref, resolve_type=False, allow_missing=True) if ptr_info and ptr_info.table_type == 'ObjectType': if irtyputils.is_inbound_ptrref(ptrref): far_pid = ir_set.path_id.src_path() assert far_pid is not None else: far_pid = ir_set.path_id else: far_pid = ir_set.path_id # Link range. map_rvar = new_pointer_rvar(rptr, src_rvar=src_rvar, ctx=ctx) include_rvar(ctx.rel, map_rvar, path_id=ir_set.path_id.ptr_path(), ctx=ctx) tgt_ref = pathctx.get_rvar_path_identity_var(set_rvar, far_pid, env=ctx.env) pathctx.get_path_identity_output(ctx.rel, far_pid, env=ctx.env) cond = astutils.new_binop(tgt_ref, ctx.rel, 'IN') stmt.where_clause = astutils.extend_binop(stmt.where_clause, cond) return set_rvar
def rel_join(query: pgast.SelectStmt, right_rvar: pgast.PathRangeVar, *, ctx: context.CompilerContextLevel) -> None: condition = None for path_id in right_rvar.query.path_scope: lref = maybe_get_path_var(query, path_id, aspect='identity', ctx=ctx) if lref is None: lref = maybe_get_path_var(query, path_id, aspect='value', ctx=ctx) if lref is None: continue rref = pathctx.get_rvar_path_identity_var(right_rvar, path_id, env=ctx.env) assert isinstance(lref, pgast.ColumnRef) assert isinstance(rref, pgast.ColumnRef) path_cond = astutils.join_condition(lref, rref) condition = astutils.extend_binop(condition, path_cond) if condition is None: join_type = 'cross' else: join_type = 'inner' if not query.from_clause: query.from_clause.append(right_rvar) if condition is not None: query.where_clause = astutils.extend_binop(query.where_clause, condition) else: larg = query.from_clause[0] rarg = right_rvar query.from_clause[0] = pgast.JoinExpr(type=join_type, larg=larg, rarg=rarg, quals=condition)