PostgreSQL查询优化中对消除外连接的处理过程是什么
本篇内容介绍了“PostgreSQL查询优化中对消除外连接的处理过程是什么”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！
站在用户的角度思考问题，与客户深入沟通，找到方城网站设计与方城网站推广的解决方案，凭借多年的经验，让设计与互联网技术结合，创造个性化、用户体验好的作品，建站类型包括：网站建设、成都网站设计、企业官网、英文网站、手机端网站、网站推广、域名与空间、虚拟空间、企业邮箱。业务覆盖方城地区。
使用的测试脚本:
drop table if exists t_null1; create table t_null1(c1 int); insert into t_null1 values(1); insert into t_null1 values(2); insert into t_null1 values(null); drop table if exists t_null2; create table t_null2(c1 int); insert into t_null2 values(1); insert into t_null2 values(null);
一、基本概念
消除外连接的代码注释说明如下:
/* * reduce_outer_joins * Attempt to reduce outer joins to plain inner joins. * * The idea here is that given a query like * SELECT ... FROM a LEFT JOIN b ON (...) WHERE b.y = 42; * we can reduce the LEFT JOIN to a plain JOIN if the "=" operator in WHERE * is strict. The strict operator will always return NULL, causing the outer * WHERE to fail, on any row where the LEFT JOIN filled in NULLs for b's * columns. Therefore, there's no need for the join to produce null-extended * rows in the first place --- which makes it a plain join not an outer join. * (This scenario may not be very likely in a query written out by hand, but * it's reasonably likely when pushing quals down into complex views.) * * More generally, an outer join can be reduced in strength if there is a * strict qual above it in the qual tree that constrains a Var from the * nullable side of the join to be non-null. (For FULL joins this applies * to each side separately.) * * Another transformation we apply here is to recognize cases like * SELECT ... FROM a LEFT JOIN b ON (a.x = b.y) WHERE b.y IS NULL; * If the join clause is strict for b.y, then only null-extended rows could * pass the upper WHERE, and we can conclude that what the query is really * specifying is an anti-semijoin. We change the join type from JOIN_LEFT * to JOIN_ANTI. The IS NULL clause then becomes redundant, and must be * removed to prevent bogus selectivity calculations, but we leave it to * distribute_qual_to_rels to get rid of such clauses. * * Also, we get rid of JOIN_RIGHT cases by flipping them around to become * JOIN_LEFT. This saves some code here and in some later planner routines, * but the main reason to do it is to not need to invent a JOIN_REVERSE_ANTI * join type. * * To ease recognition of strict qual clauses, we require this routine to be * run after expression preprocessing (i.e., qual canonicalization and JOIN * alias-var expansion). */
有两种类型的外连接可以被消除,第一种是形如以下形式的语句:
SELECT ... FROM a LEFT JOIN b ON (...) WHERE b.y = 42;
这种语句如满足条件可变换为内连接(INNER_JOIN).
之所以可以变换为内连接,那是因为这样的语句与内连接处理的结果是一样的,原因是在Nullable-Side端(需要填充NULL值的一端),存在过滤条件保证这一端不可能是NULL值,比如IS NOT NULL/y = 42这类强(strict)过滤条件.
testdb=# explain verbose select * from t_null1 a left join t_null2 b on a.c1 = b.c1; QUERY PLAN -------------------------------------------------------------------------------- Merge Left Join (cost=359.57..860.00 rows=32512 width=8) -- 外连接 Output: a.c1, b.c1 Merge Cond: (a.c1 = b.c1) -> Sort (cost=179.78..186.16 rows=2550 width=4) Output: a.c1 Sort Key: a.c1 -> Seq Scan on public.t_null1 a (cost=0.00..35.50 rows=2550 width=4) Output: a.c1 -> Sort (cost=179.78..186.16 rows=2550 width=4) Output: b.c1 Sort Key: b.c1 -> Seq Scan on public.t_null2 b (cost=0.00..35.50 rows=2550 width=4) Output: b.c1 (13 rows) testdb=# explain verbose select * from t_null1 a left join t_null2 b on a.c1 = b.c1 where b.c1 = 1; QUERY PLAN ------------------------------------------------------------------------------ Nested Loop (cost=0.00..85.89 rows=169 width=8) -- 外连接(Left关键字)已被消除 Output: a.c1, b.c1 -> Seq Scan on public.t_null1 a (cost=0.00..41.88 rows=13 width=4) Output: a.c1 Filter: (a.c1 = 1) -> Materialize (cost=0.00..41.94 rows=13 width=4) Output: b.c1 -> Seq Scan on public.t_null2 b (cost=0.00..41.88 rows=13 width=4) Output: b.c1 Filter: (b.c1 = 1) (10 rows)
第二种形如:
SELECT ... FROM a LEFT JOIN b ON (a.x = b.y) WHERE b.y IS NULL;
这种语句如满足条件可以变换为反半连接(ANTI-SEMIJOIN).
过滤条件已明确要求Nullable-Side端y IS NULL,如果连接条件是a.x = b.y这类严格(strict)的条件,那么这样的外连接与反半连接的结果是一样的.
testdb=# explain verbose select * from t_null1 a left join t_null2 b on a.c1 = b.c1 where b.c1 is null; QUERY PLAN -------------------------------------------------------------------------------- Hash Anti Join (cost=67.38..152.44 rows=1275 width=8) -- 变换为反连接 Output: a.c1, b.c1 Hash Cond: (a.c1 = b.c1) -> Seq Scan on public.t_null1 a (cost=0.00..35.50 rows=2550 width=4) Output: a.c1 -> Hash (cost=35.50..35.50 rows=2550 width=4) Output: b.c1 -> Seq Scan on public.t_null2 b (cost=0.00..35.50 rows=2550 width=4) Output: b.c1 (9 rows)
值得一提的是,在PG中,形如SELECT ... FROM a LEFT JOIN b ON (...) WHERE b.y = 42;这样的SQL语句,WHERE b.y = 42这类条件可以视为连接的上层过滤条件,在查询树中,Jointree->fromlist(元素类型为JoinExpr)与Jointree->quals处于同一层次,由于JoinExpr中的quals为同层条件,因此其上层即为Jointree->quals.有兴趣的可以查看日志输出查看Query查询树结构.
二、源码解读
消除外连接的代码在主函数subquery_planner中,通过调用reduce_outer_joins函数实现,代码片段如下:
/* * If we have any outer joins, try to reduce them to plain inner joins. * This step is most easily done after we've done expression * preprocessing. */ if (hasOuterJoins) reduce_outer_joins(root);
reduce_outer_joins
相关的数据结构和依赖的子函数:
reduce_outer_joins_state
typedef struct reduce_outer_joins_state
{
Relids relids; /* base relids within this subtree */
bool contains_outer; /* does subtree contain outer join(s)? */
List *sub_states; /* List of states for subtree components */
} reduce_outer_joins_state;BitmapXX
typedef struct Bitmapset
{
int nwords; /* number of words in array */
bitmapword words[FLEXIBLE_ARRAY_MEMBER]; /* really [nwords] */
} Bitmapset;
#define WORDNUM(x) ((x) / BITS_PER_BITMAPWORD)
#define BITNUM(x) ((x) % BITS_PER_BITMAPWORD)
/* The unit size can be adjusted by changing these three declarations: */
#define BITS_PER_BITMAPWORD 32
typedef uint32 bitmapword; /* must be an unsigned type */
/*
* bms_make_singleton - build a bitmapset containing a single member
*/
Bitmapset *
bms_make_singleton(int x)
{
Bitmapset *result;
int wordnum,
bitnum;
if (x < 0)
elog(ERROR, "negative bitmapset member not allowed");
wordnum = WORDNUM(x);
bitnum = BITNUM(x);
result = (Bitmapset *) palloc0(BITMAPSET_SIZE(wordnum + 1));
result->nwords = wordnum + 1;
result->words[wordnum] = ((bitmapword) 1 << bitnum);
return result;
}
/*
* bms_add_member - add a specified member to set
*
* Input set is modified or recycled!
*/
Bitmapset *
bms_add_member(Bitmapset *a, int x)
{
int wordnum,
bitnum;
if (x < 0)
elog(ERROR, "negative bitmapset member not allowed");
if (a == NULL)
return bms_make_singleton(x);
wordnum = WORDNUM(x);
bitnum = BITNUM(x);
/* enlarge the set if necessary */
if (wordnum >= a->nwords)
{
int oldnwords = a->nwords;
int i;
a = (Bitmapset *) repalloc(a, BITMAPSET_SIZE(wordnum + 1));
a->nwords = wordnum + 1;
/* zero out the enlarged portion */
for (i = oldnwords; i < a->nwords; i++)
a->words[i] = 0;
}
a->words[wordnum] |= ((bitmapword) 1 << bitnum);
return a;
}find_nonnullable_rels
/*
* find_nonnullable_rels
* Determine which base rels are forced nonnullable by given clause.
*
* Returns the set of all Relids that are referenced in the clause in such
* a way that the clause cannot possibly return TRUE if any of these Relids
* is an all-NULL row. (It is OK to err on the side of conservatism; hence
* the analysis here is simplistic.)
*
* The semantics here are subtly different from contain_nonstrict_functions:
* that function is concerned with NULL results from arbitrary expressions,
* but here we assume that the input is a Boolean expression, and wish to
* see if NULL inputs will provably cause a FALSE-or-NULL result. We expect
* the expression to have been AND/OR flattened and converted to implicit-AND
* format.
*
* Note: this function is largely duplicative of find_nonnullable_vars().
* The reason not to simplify this function into a thin wrapper around
* find_nonnullable_vars() is that the tested conditions really are different:
* a clause like "t1.v1 IS NOT NULL OR t1.v2 IS NOT NULL" does not prove
* that either v1 or v2 can't be NULL, but it does prove that the t1 row
* as a whole can't be all-NULL.
*
* top_level is true while scanning top-level AND/OR structure; here, showing
* the result is either FALSE or NULL is good enough. top_level is false when
* we have descended below a NOT or a strict function: now we must be able to
* prove that the subexpression goes to NULL.
*
* We don't use expression_tree_walker here because we don't want to descend
* through very many kinds of nodes; only the ones we can be sure are strict.
*/
Relids
find_nonnullable_rels(Node *clause)
{
return find_nonnullable_rels_walker(clause, true);
}
static Relids
find_nonnullable_rels_walker(Node *node, bool top_level)
{
Relids result = NULL;
ListCell *l;
if (node == NULL)
return NULL;
if (IsA(node, Var))
{
Var *var = (Var *) node;
if (var->varlevelsup == 0)
result = bms_make_singleton(var->varno);
}
else if (IsA(node, List))
{
/*
* At top level, we are examining an implicit-AND list: if any of the
* arms produces FALSE-or-NULL then the result is FALSE-or-NULL. If
* not at top level, we are examining the arguments of a strict
* function: if any of them produce NULL then the result of the
* function must be NULL. So in both cases, the set of nonnullable
* rels is the union of those found in the arms, and we pass down the
* top_level flag unmodified.
*/
foreach(l, (List *) node)
{
result = bms_join(result,
find_nonnullable_rels_walker(lfirst(l),
top_level));
}
}
else if (IsA(node, FuncExpr))
{
FuncExpr *expr = (FuncExpr *) node;
if (func_strict(expr->funcid))
result = find_nonnullable_rels_walker((Node *) expr->args, false);
}
else if (IsA(node, OpExpr))
{
OpExpr *expr = (OpExpr *) node;
set_opfuncid(expr);
if (func_strict(expr->opfuncid))
result = find_nonnullable_rels_walker((Node *) expr->args, false);
}
else if (IsA(node, ScalarArrayOpExpr))
{
ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;
if (is_strict_saop(expr, true))
result = find_nonnullable_rels_walker((Node *) expr->args, false);
}
else if (IsA(node, BoolExpr))
{
BoolExpr *expr = (BoolExpr *) node;
switch (expr->boolop)
{
case AND_EXPR:
/* At top level we can just recurse (to the List case) */
if (top_level)
{
result = find_nonnullable_rels_walker((Node *) expr->args,
top_level);
break;
}
/*
* Below top level, even if one arm produces NULL, the result
* could be FALSE (hence not NULL). However, if *all* the
* arms produce NULL then the result is NULL, so we can take
* the intersection of the sets of nonnullable rels, just as
* for OR. Fall through to share code.
*/
/* FALL THRU */
case OR_EXPR:
/*
* OR is strict if all of its arms are, so we can take the
* intersection of the sets of nonnullable rels for each arm.
* This works for both values of top_level.
*/
foreach(l, expr->args)
{
Relids subresult;
subresult = find_nonnullable_rels_walker(lfirst(l),
top_level);
if (result == NULL) /* first subresult? */
result = subresult;
else
result = bms_int_members(result, subresult);
/*
* If the intersection is empty, we can stop looking. This
* also justifies the test for first-subresult above.
*/
if (bms_is_empty(result))
break;
}
break;
case NOT_EXPR:
/* NOT will return null if its arg is null */
result = find_nonnullable_rels_walker((Node *) expr->args,
false);
break;
default:
elog(ERROR, "unrecognized boolop: %d", (int) expr->boolop);
break;
}
}
else if (IsA(node, RelabelType))
{
RelabelType *expr = (RelabelType *) node;
result = find_nonnullable_rels_walker((Node *) expr->arg, top_level);
}
else if (IsA(node, CoerceViaIO))
{
/* not clear this is useful, but it can't hurt */
CoerceViaIO *expr = (CoerceViaIO *) node;
result = find_nonnullable_rels_walker((Node *) expr->arg, top_level);
}
else if (IsA(node, ArrayCoerceExpr))
{
/* ArrayCoerceExpr is strict at the array level; ignore elemexpr */
ArrayCoerceExpr *expr = (ArrayCoerceExpr *) node;
result = find_nonnullable_rels_walker((Node *) expr->arg, top_level);
}
else if (IsA(node, ConvertRowtypeExpr))
{
/* not clear this is useful, but it can't hurt */
ConvertRowtypeExpr *expr = (ConvertRowtypeExpr *) node;
result = find_nonnullable_rels_walker((Node *) expr->arg, top_level);
}
else if (IsA(node, CollateExpr))
{
CollateExpr *expr = (CollateExpr *) node;
result = find_nonnullable_rels_walker((Node *) expr->arg, top_level);
}
else if (IsA(node, NullTest))
{
/* IS NOT NULL can be considered strict, but only at top level */
NullTest *expr = (NullTest *) node;
if (top_level && expr->nulltesttype == IS_NOT_NULL && !expr->argisrow)
result = find_nonnullable_rels_walker((Node *) expr->arg, false);
}
else if (IsA(node, BooleanTest))
{
/* Boolean tests that reject NULL are strict at top level */
BooleanTest *expr = (BooleanTest *) node;
if (top_level &&
(expr->booltesttype == IS_TRUE ||
expr->booltesttype == IS_FALSE ||
expr->booltesttype == IS_NOT_UNKNOWN))
result = find_nonnullable_rels_walker((Node *) expr->arg, false);
}
else if (IsA(node, PlaceHolderVar))
{
PlaceHolderVar *phv = (PlaceHolderVar *) node;
result = find_nonnullable_rels_walker((Node *) phv->phexpr, top_level);
}
return result;
}三、跟踪分析
外连接->内连接
测试脚本:
select * from t_null1 a left join t_null2 b on a.c1 = b.c1 where b.c1 = 1;
gdb跟踪:
(gdb) b reduce_outer_joins
Breakpoint 1 at 0x77faf5: file prepjointree.c, line 2484.
(gdb) c
Continuing.
Breakpoint 1, reduce_outer_joins (root=0x2eafa98) at prepjointree.c:2484
2484 state = reduce_outer_joins_pass1((Node *) root->parse->jointree);
(gdb) b reduce_outer_joins
Breakpoint 1 at 0x77faf5: file prepjointree.c, line 2484.
...
#进入reduce_outer_joins_pass1
(gdb) step
reduce_outer_joins_pass1 (jtnode=0x2ea4af8) at prepjointree.c:2504
...
(gdb) p *f
$2 = {type = T_FromExpr, fromlist = 0x2ea4668, quals = 0x2edcae8}
#进入FromExpr分支
(gdb) n
2527 sub_state = reduce_outer_joins_pass1(lfirst(l));
##递归调用
(gdb) step
reduce_outer_joins_pass1 (jtnode=0x2dd40f0) at prepjointree.c:2504
2504 result = (reduce_outer_joins_state *)
##进入JoinExpr分支
2534 else if (IsA(jtnode, JoinExpr))
(gdb)
2536 JoinExpr *j = (JoinExpr *) jtnode;
(gdb) p *j
$3 = {type = T_JoinExpr, jointype = JOIN_LEFT, isNatural = false, larg = 0x2dd49e0, rarg = 0x2dd4c68, usingClause = 0x0,
quals = 0x2edc828, alias = 0x0, rtindex = 3}
###递归调用
2543 sub_state = reduce_outer_joins_pass1(j->larg);
(gdb) step
reduce_outer_joins_pass1 (jtnode=0x2dd49e0) at prepjointree.c:2504
2504 result = (reduce_outer_joins_state *)
###进入RangeTblRef分支
2512 if (IsA(jtnode, RangeTblRef))
(gdb)
2514 int varno = ((RangeTblRef *) jtnode)->rtindex;
...
###JoinExpr处理完毕
2549 sub_state = reduce_outer_joins_pass1(j->rarg);
(gdb)
2551 sub_state->relids);
(gdb)
2550 result->relids = bms_add_members(result->relids,
(gdb)
2552 result->contains_outer |= sub_state->contains_outer;
(gdb)
2553 result->sub_states = lappend(result->sub_states, sub_state);
(gdb)
2558 return result;
(gdb) p *result
$12 = {relids = 0x2ea61e8, contains_outer = true, sub_states = 0x2edcbc8}
(gdb) p *result->relids
$13 = {nwords = 1, words = 0x2ea61ec}
(gdb) p *result->sub_states
$14 = {type = T_List, length = 2, head = 0x2edcba8, tail = 0x2edcc40}
(gdb) n
2559 }
(gdb)
##回到FromExpr
...
2523 foreach(l, f->fromlist)
(gdb) p *result
$18 = {relids = 0x2edcc60, contains_outer = true, sub_states = 0x2edcc98}
#回到reduce_outer_joins
reduce_outer_joins (root=0x2eafa98) at prepjointree.c:2487
2487 if (state == NULL || !state->contains_outer)
(gdb) p *state
$21 = {relids = 0x2edcc60, contains_outer = true, sub_states = 0x2edcc98}
(gdb) p *state->relids[0]->words
$30 = 6 -->Relids,1 & 2,即1<<1 | 1 << 2
#进入reduce_outer_joins_pass2
(gdb) step
reduce_outer_joins_pass2 (jtnode=0x2ea4af8, state=0x2edcb18, root=0x2eafa98, nonnullable_rels=0x0, nonnullable_vars=0x0,
forced_null_vars=0x0) at prepjointree.c:2583
2583 if (jtnode == NULL)
...
#进入FromExpr分支
2587 else if (IsA(jtnode, FromExpr))
(gdb)
2589 FromExpr *f = (FromExpr *) jtnode;
...
#寻找FromExpr中存在过滤条件为NOT NULL的Relids
(gdb) n
2597 pass_nonnullable_rels = find_nonnullable_rels(f->quals);
(gdb)
2598 pass_nonnullable_rels = bms_add_members(pass_nonnullable_rels,
(gdb) p pass_nonnullable_rels->words[0]
$34 = 4 -- rtindex = 2的Relid
#寻找NOT NULL's Vars
2601 pass_nonnullable_vars = find_nonnullable_vars(f->quals);
(gdb)
2602 pass_nonnullable_vars = list_concat(pass_nonnullable_vars,
(gdb)
2604 pass_forced_null_vars = find_forced_null_vars(f->quals);
(gdb) p *pass_nonnullable_vars
$35 = {type = T_List, length = 1, head = 0x2edcce0, tail = 0x2edcce0}
(gdb) p *(Node *)pass_nonnullable_vars->head->data.ptr_value
$36 = {type = T_Var}
(gdb) p *(Var *)pass_nonnullable_vars->head->data.ptr_value
$37 = {xpr = {type = T_Var}, varno = 2, varattno = 1, vartype = 23, vartypmod = -1, varcollid = 0, varlevelsup = 0,
varnoold = 2, varoattno = 1, location = 65} -- rtindex=2的RTE,属性编号为1的字段
##递归调用reduce_outer_joins_pass2
(gdb)
2614 reduce_outer_joins_pass2(lfirst(l), sub_state, root,
(gdb) step
reduce_outer_joins_pass2 (jtnode=0x2dd40f0, state=0x2edcb48, root=0x2eafa98, nonnullable_rels=0x2edccc8,
nonnullable_vars=0x2edcd00, forced_null_vars=0x0) at prepjointree.c:2583
2583 if (jtnode == NULL)
##进入JoinExpr分支
2622 else if (IsA(jtnode, JoinExpr))
(gdb)
2624 JoinExpr *j = (JoinExpr *) jtnode;
...
(gdb) p *right_state->relids[0]->words
$44 = 4 -->2号RTE
(gdb) p *left_state->relids[0]->words
$45 = 2 -->1号RTE
(gdb) p rtindex
$46 = 3 -->Jointree整体作为3号RTE存在
...
2633 switch (jointype)
(gdb)
2638 if (bms_overlap(nonnullable_rels, right_state->relids))
(gdb) p *nonnullable_rels->words
$49 = 4 -->2号RTE
(gdb) p right_state->relids->words[0]
$50 = 4 -->2号RTE
##转换为内连接
(gdb) n
2639 jointype = JOIN_INNER;
...
##修改RTE的连接类型
(gdb)
2724 if (rtindex && jointype != j->jointype)
(gdb)
2726 RangeTblEntry *rte = rt_fetch(rtindex, root->parse->rtable);
(gdb)
2730 rte->jointype = jointype;
(gdb) p *rte
$54 = {type = T_RangeTblEntry, rtekind = RTE_JOIN, relid = 0, relkind = 0 '\000', tablesample = 0x0, subquery = 0x0,
security_barrier = false, jointype = JOIN_LEFT, joinaliasvars = 0x0, functions = 0x0, funcordinality = false,
tablefunc = 0x0, values_lists = 0x0, ctename = 0x0, ctelevelsup = 0, self_reference = false, coltypes = 0x0,
coltypmods = 0x0, colcollations = 0x0, enrname = 0x0, enrtuples = 0, alias = 0x0, eref = 0x2ea4498, lateral = false,
inh = false, inFromCl = true, requiredPerms = 2, checkAsUser = 0, selectedCols = 0x0, insertedCols = 0x0,
updatedCols = 0x0, securityQuals = 0x0}
(gdb) n
2732 j->jointype = jointype;
...
#回到上层的reduce_outer_joins_pass2
(gdb)
reduce_outer_joins_pass2 (jtnode=0x2ea4af8, state=0x2edcb18, root=0x2eafa98, nonnullable_rels=0x0, nonnullable_vars=0x0,
forced_null_vars=0x0) at prepjointree.c:2609
2609 forboth(l, f->fromlist, s, state->sub_states)
#回到主函数reduce_outer_joins
2844 }
(gdb)
reduce_outer_joins (root=0x2eafa98) at prepjointree.c:2492
2492 }
(gdb)
#DONE!外连接->反连接
测试脚本:
select * from t_null1 a left join t_null2 b on a.c1 = b.c1 where b.c1 is null;
gdb跟踪,与转换为内连接不同的地方在于reduce_outer_joins_pass2函数中find_forced_null_vars在这里是可以找到相应的Vars的:
(gdb) b prepjointree.c:2702
Breakpoint 3 at 0x78023c: file prepjointree.c, line 2702.
(gdb) c
Continuing.
Breakpoint 3, reduce_outer_joins_pass2 (jtnode=0x2dd40f0, state=0x2edc9b8, root=0x2eafa98, nonnullable_rels=0x0,
nonnullable_vars=0x0, forced_null_vars=0x2edcb70) at prepjointree.c:2703
2703 if (jointype == JOIN_LEFT)
#尝试转换为内连接,但不成功,仍为左连接
2707 local_nonnullable_vars = find_nonnullable_vars(j->quals);
(gdb)
2708 computed_local_nonnullable_vars = true;
(gdb) p *local_nonnullable_vars
$56 = {type = T_List, length = 2, head = 0x2edcba0, tail = 0x2edcbf0}
(gdb) p *(Var *)local_nonnullable_vars->head->data.ptr_value
$57 = {xpr = {type = T_Var}, varno = 1, varattno = 1, vartype = 23, vartypmod = -1, varcollid = 0, varlevelsup = 0,
varnoold = 1, varoattno = 1, location = 47}
(gdb) p *(Var *)local_nonnullable_vars->head->next->data.ptr_value
$58 = {xpr = {type = T_Var}, varno = 2, varattno = 1, vartype = 23, vartypmod = -1, varcollid = 0, varlevelsup = 0,
varnoold = 2, varoattno = 1, location = 54}
(gdb) p *(Var *)forced_null_vars->head->data.ptr_value
$61 = {xpr = {type = T_Var}, varno = 2, varattno = 1, vartype = 23, vartypmod = -1, varcollid = 0, varlevelsup = 0,
varnoold = 2, varoattno = 1, location = 65}
(gdb) p *(Var *)overlap->head->data.ptr_value
$63 = {xpr = {type = T_Var}, varno = 2, varattno = 1, vartype = 23, vartypmod = -1, varcollid = 0, varlevelsup = 0,
varnoold = 2, varoattno = 1, location = 54}
...
#转换为反连接
2717 if (overlap != NIL &&
(gdb)
2720 jointype = JOIN_ANTI;
(gdb) c
Continuing.“PostgreSQL查询优化中对消除外连接的处理过程是什么”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注创新互联网站，小编将为大家输出更多高质量的实用文章！
本文标题：PostgreSQL查询优化中对消除外连接的处理过程是什么
浏览地址：http://ybzwz.com/article/jojgii.html
