Inner Unique: true
Hash Cond: (bar.f1 = foo.f1)
-> Append
- -> Seq Scan on public.bar
- Output: bar.f1, bar.f2, bar.ctid, bar.*, bar.tableoid
- -> Foreign Scan on public.bar2 bar_1
+ -> Seq Scan on public.bar bar_1
Output: bar_1.f1, bar_1.f2, bar_1.ctid, bar_1.*, bar_1.tableoid
+ -> Foreign Scan on public.bar2 bar_2
+ Output: bar_2.f1, bar_2.f2, bar_2.ctid, bar_2.*, bar_2.tableoid
Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR UPDATE
-> Hash
Output: foo.ctid, foo.f1, foo.*, foo.tableoid
Output: foo.ctid, foo.f1, foo.*, foo.tableoid
Group Key: foo.f1
-> Append
- -> Seq Scan on public.foo
- Output: foo.ctid, foo.f1, foo.*, foo.tableoid
- -> Foreign Scan on public.foo2 foo_1
+ -> Seq Scan on public.foo foo_1
Output: foo_1.ctid, foo_1.f1, foo_1.*, foo_1.tableoid
+ -> Foreign Scan on public.foo2 foo_2
+ Output: foo_2.ctid, foo_2.f1, foo_2.*, foo_2.tableoid
Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
(23 rows)
Inner Unique: true
Hash Cond: (bar.f1 = foo.f1)
-> Append
- -> Seq Scan on public.bar
- Output: bar.f1, bar.f2, bar.ctid, bar.*, bar.tableoid
- -> Foreign Scan on public.bar2 bar_1
+ -> Seq Scan on public.bar bar_1
Output: bar_1.f1, bar_1.f2, bar_1.ctid, bar_1.*, bar_1.tableoid
+ -> Foreign Scan on public.bar2 bar_2
+ Output: bar_2.f1, bar_2.f2, bar_2.ctid, bar_2.*, bar_2.tableoid
Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct2 FOR SHARE
-> Hash
Output: foo.ctid, foo.f1, foo.*, foo.tableoid
Output: foo.ctid, foo.f1, foo.*, foo.tableoid
Group Key: foo.f1
-> Append
- -> Seq Scan on public.foo
- Output: foo.ctid, foo.f1, foo.*, foo.tableoid
- -> Foreign Scan on public.foo2 foo_1
+ -> Seq Scan on public.foo foo_1
Output: foo_1.ctid, foo_1.f1, foo_1.*, foo_1.tableoid
+ -> Foreign Scan on public.foo2 foo_2
+ Output: foo_2.ctid, foo_2.f1, foo_2.*, foo_2.tableoid
Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
(23 rows)
Output: foo.ctid, foo.f1, foo.*, foo.tableoid
Group Key: foo.f1
-> Append
- -> Seq Scan on public.foo
- Output: foo.ctid, foo.f1, foo.*, foo.tableoid
- -> Foreign Scan on public.foo2 foo_1
+ -> Seq Scan on public.foo foo_1
Output: foo_1.ctid, foo_1.f1, foo_1.*, foo_1.tableoid
+ -> Foreign Scan on public.foo2 foo_2
+ Output: foo_2.ctid, foo_2.f1, foo_2.*, foo_2.tableoid
Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
-> Hash Join
Output: bar_1.f1, (bar_1.f2 + 100), bar_1.f3, bar_1.ctid, foo.ctid, foo.*, foo.tableoid
Output: foo.ctid, foo.f1, foo.*, foo.tableoid
Group Key: foo.f1
-> Append
- -> Seq Scan on public.foo
- Output: foo.ctid, foo.f1, foo.*, foo.tableoid
- -> Foreign Scan on public.foo2 foo_1
+ -> Seq Scan on public.foo foo_1
Output: foo_1.ctid, foo_1.f1, foo_1.*, foo_1.tableoid
+ -> Foreign Scan on public.foo2 foo_2
+ Output: foo_2.ctid, foo_2.f1, foo_2.*, foo_2.tableoid
Remote SQL: SELECT f1, f2, f3, ctid FROM public.loct1
(39 rows)
Merge Cond: (foo.f1 = loct1.f1)
-> Merge Append
Sort Key: foo.f1
- -> Index Scan using i_foo_f1 on public.foo
- Output: foo.f1, foo.f2
- -> Foreign Scan on public.foo2 foo_1
+ -> Index Scan using i_foo_f1 on public.foo foo_1
Output: foo_1.f1, foo_1.f2
+ -> Foreign Scan on public.foo2 foo_2
+ Output: foo_2.f1, foo_2.f2
Remote SQL: SELECT f1, f2 FROM public.loct1 ORDER BY f1 ASC NULLS LAST
-> Index Only Scan using i_loct1_f1 on public.loct1
Output: loct1.f1
Merge Cond: (foo.f1 = loct1.f1)
-> Merge Append
Sort Key: foo.f1
- -> Index Scan using i_foo_f1 on public.foo
- Output: foo.f1, foo.f2
- -> Foreign Scan on public.foo2 foo_1
+ -> Index Scan using i_foo_f1 on public.foo foo_1
Output: foo_1.f1, foo_1.f2
+ -> Foreign Scan on public.foo2 foo_2
+ Output: foo_2.f1, foo_2.f2
Remote SQL: SELECT f1, f2 FROM public.loct1 ORDER BY f1 ASC NULLS LAST
-> Index Only Scan using i_loct1_f1 on public.loct1
Output: loct1.f1
Sort Key: t1.a, t3.c
-> Append
-> Foreign Scan
- Relations: ((ftprt1_p1 t1) INNER JOIN (ftprt2_p1 t2)) INNER JOIN (ftprt1_p1 t3)
+ Relations: ((ftprt1_p1 t1_1) INNER JOIN (ftprt2_p1 t2_1)) INNER JOIN (ftprt1_p1 t3_1)
-> Foreign Scan
- Relations: ((ftprt1_p2 t1_1) INNER JOIN (ftprt2_p2 t2_1)) INNER JOIN (ftprt1_p2 t3_1)
+ Relations: ((ftprt1_p2 t1_2) INNER JOIN (ftprt2_p2 t2_2)) INNER JOIN (ftprt1_p2 t3_2)
(7 rows)
SELECT t1.a,t2.b,t3.c FROM fprt1 t1 INNER JOIN fprt2 t2 ON (t1.a = t2.b) INNER JOIN fprt1 t3 ON (t2.b = t3.a) WHERE t1.a % 25 =0 ORDER BY 1,2,3;
-> Hash Full Join
Hash Cond: (t1.a = t2.b)
-> Append
- -> Foreign Scan on ftprt1_p1 t1
- -> Foreign Scan on ftprt1_p2 t1_1
+ -> Foreign Scan on ftprt1_p1 t1_1
+ -> Foreign Scan on ftprt1_p2 t1_2
-> Hash
-> Append
- -> Foreign Scan on ftprt2_p1 t2
- -> Foreign Scan on ftprt2_p2 t2_1
+ -> Foreign Scan on ftprt2_p1 t2_1
+ -> Foreign Scan on ftprt2_p2 t2_2
(11 rows)
SELECT t1.wr, t2.wr FROM (SELECT t1 wr, a FROM fprt1 t1 WHERE t1.a % 25 = 0) t1 FULL JOIN (SELECT t2 wr, b FROM fprt2 t2 WHERE t2.b % 25 = 0) t2 ON (t1.a = t2.b) ORDER BY 1,2;
Sort Key: t1.a, t1.b
-> Append
-> Foreign Scan
- Relations: (ftprt1_p1 t1) INNER JOIN (ftprt2_p1 t2)
+ Relations: (ftprt1_p1 t1_1) INNER JOIN (ftprt2_p1 t2_1)
-> Foreign Scan
- Relations: (ftprt1_p2 t1_1) INNER JOIN (ftprt2_p2 t2_1)
+ Relations: (ftprt1_p2 t1_2) INNER JOIN (ftprt2_p2 t2_2)
(7 rows)
SELECT t1.a,t1.b FROM fprt1 t1, LATERAL (SELECT t2.a, t2.b FROM fprt2 t2 WHERE t1.a = t2.b AND t1.b = t2.a) q WHERE t1.a%25 = 0 ORDER BY 1,2;
Sort Key: fprt1.a, fprt2.b
-> Append
-> Hash Full Join
- Hash Cond: (fprt1.a = fprt2.b)
- -> Foreign Scan on ftprt1_p1 fprt1
+ Hash Cond: (fprt1_1.a = fprt2_1.b)
+ -> Foreign Scan on ftprt1_p1 fprt1_1
-> Hash
- -> Foreign Scan on ftprt2_p1 fprt2
+ -> Foreign Scan on ftprt2_p1 fprt2_1
-> Hash Full Join
- Hash Cond: (fprt1_1.a = fprt2_1.b)
- -> Foreign Scan on ftprt1_p2 fprt1_1
+ Hash Cond: (fprt1_2.a = fprt2_2.b)
+ -> Foreign Scan on ftprt1_p2 fprt1_2
-> Hash
- -> Foreign Scan on ftprt2_p2 fprt2_1
+ -> Foreign Scan on ftprt2_p2 fprt2_2
(13 rows)
SELECT t1.a, t1.phv, t2.b, t2.phv FROM (SELECT 't1_phv' phv, * FROM fprt1 WHERE a % 25 = 0) t1 FULL JOIN (SELECT 't2_phv' phv, * FROM fprt2 WHERE b % 25 = 0) t2 ON (t1.a = t2.b) ORDER BY t1.a, t2.b;
-> Hash Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Foreign Scan on ftprt2_p1 t2
- -> Foreign Scan on ftprt2_p2 t2_1
+ -> Foreign Scan on ftprt2_p1 t2_1
+ -> Foreign Scan on ftprt2_p2 t2_2
-> Hash
-> Append
- -> Foreign Scan on ftprt1_p1 t1
- -> Foreign Scan on ftprt1_p2 t1_1
+ -> Foreign Scan on ftprt1_p1 t1_1
+ -> Foreign Scan on ftprt1_p2 t1_2
(12 rows)
SELECT t1.a, t2.b FROM fprt1 t1 INNER JOIN fprt2 t2 ON (t1.a = t2.b) WHERE t1.a % 25 = 0 ORDER BY 1,2 FOR UPDATE OF t1;
Group Key: pagg_tab.a
Filter: (avg(pagg_tab.b) < '22'::numeric)
-> Append
- -> Foreign Scan on fpagg_tab_p1 pagg_tab
- -> Foreign Scan on fpagg_tab_p2 pagg_tab_1
- -> Foreign Scan on fpagg_tab_p3 pagg_tab_2
+ -> Foreign Scan on fpagg_tab_p1 pagg_tab_1
+ -> Foreign Scan on fpagg_tab_p2 pagg_tab_2
+ -> Foreign Scan on fpagg_tab_p3 pagg_tab_3
(9 rows)
-- Plan with partitionwise aggregates is enabled
es->rtable = queryDesc->plannedstmt->rtable;
ExplainPreScanNode(queryDesc->planstate, &rels_used);
es->rtable_names = select_rtable_names_for_explain(es->rtable, rels_used);
- es->deparse_cxt = deparse_context_for_plan_rtable(es->rtable,
- es->rtable_names);
+ es->deparse_cxt = deparse_context_for_plan_tree(queryDesc->plannedstmt,
+ es->rtable_names);
es->printed_subplans = NULL;
/*
*rels_used = bms_add_member(*rels_used,
((ModifyTable *) plan)->exclRelRTI);
break;
+ case T_Append:
+ *rels_used = bms_add_members(*rels_used,
+ ((Append *) plan)->apprelids);
+ break;
+ case T_MergeAppend:
+ *rels_used = bms_add_members(*rels_used,
+ ((MergeAppend *) plan)->apprelids);
+ break;
default:
break;
}
* We need to work from a PlanState node, not just a Plan node, in order to
* get at the instrumentation data (if any) as well as the list of subplans.
*
- * ancestors is a list of parent PlanState nodes, most-closely-nested first.
- * These are needed in order to interpret PARAM_EXEC Params.
+ * ancestors is a list of parent Plan and SubPlan nodes, most-closely-nested
+ * first. These are needed in order to interpret PARAM_EXEC Params.
*
* relationship describes the relationship of this plan node to its parent
* (eg, "Outer", "Inner"); it can be null at top level. plan_name is an
if (haschildren)
{
ExplainOpenGroup("Plans", "Plans", false, es);
- /* Pass current PlanState as head of ancestors list for children */
- ancestors = lcons(planstate, ancestors);
+ /* Pass current Plan as head of ancestors list for children */
+ ancestors = lcons(plan, ancestors);
}
/* initPlan-s */
return;
/* Set up deparsing context */
- context = set_deparse_context_planstate(es->deparse_cxt,
- (Node *) planstate,
- ancestors);
+ context = set_deparse_context_plan(es->deparse_cxt,
+ plan,
+ ancestors);
useprefix = list_length(es->rtable) > 1;
/* Deparse each result column (we now include resjunk ones) */
char *exprstr;
/* Set up deparsing context */
- context = set_deparse_context_planstate(es->deparse_cxt,
- (Node *) planstate,
- ancestors);
+ context = set_deparse_context_plan(es->deparse_cxt,
+ planstate->plan,
+ ancestors);
/* Deparse the expression */
exprstr = deparse_expression(node, context, useprefix, false);
if (plan->numCols > 0 || plan->groupingSets)
{
/* The key columns refer to the tlist of the child plan */
- ancestors = lcons(astate, ancestors);
+ ancestors = lcons(plan, ancestors);
if (plan->groupingSets)
show_grouping_sets(outerPlanState(astate), plan, ancestors, es);
ListCell *lc;
/* Set up deparsing context */
- context = set_deparse_context_planstate(es->deparse_cxt,
- (Node *) planstate,
- ancestors);
+ context = set_deparse_context_plan(es->deparse_cxt,
+ planstate->plan,
+ ancestors);
useprefix = (list_length(es->rtable) > 1 || es->verbose);
ExplainOpenGroup("Grouping Sets", "Grouping Sets", false, es);
Group *plan = (Group *) gstate->ss.ps.plan;
/* The key columns refer to the tlist of the child plan */
- ancestors = lcons(gstate, ancestors);
+ ancestors = lcons(plan, ancestors);
show_sort_group_keys(outerPlanState(gstate), "Group Key",
plan->numCols, plan->grpColIdx,
NULL, NULL, NULL,
initStringInfo(&sortkeybuf);
/* Set up deparsing context */
- context = set_deparse_context_planstate(es->deparse_cxt,
- (Node *) planstate,
- ancestors);
+ context = set_deparse_context_plan(es->deparse_cxt,
+ plan,
+ ancestors);
useprefix = (list_length(es->rtable) > 1 || es->verbose);
for (keyno = 0; keyno < nkeys; keyno++)
ListCell *lc;
/* Set up deparsing context */
- context = set_deparse_context_planstate(es->deparse_cxt,
- (Node *) planstate,
- ancestors);
+ context = set_deparse_context_plan(es->deparse_cxt,
+ planstate->plan,
+ ancestors);
useprefix = list_length(es->rtable) > 1;
/* Get the tablesample method name */
* Explain a list of SubPlans (or initPlans, which also use SubPlan nodes).
*
* The ancestors list should already contain the immediate parent of these
- * SubPlanStates.
+ * SubPlans.
*/
static void
ExplainSubPlans(List *plans, List *ancestors,
es->printed_subplans = bms_add_member(es->printed_subplans,
sp->plan_id);
+ /*
+ * Treat the SubPlan node as an ancestor of the plan node(s) within
+ * it, so that ruleutils.c can find the referents of subplan
+ * parameters.
+ */
+ ancestors = lcons(sp, ancestors);
+
ExplainNode(sps->planstate, ancestors,
relationship, sp->plan_name, es);
+
+ ancestors = list_delete_first(ancestors);
}
}
pstmt->planTree = plan;
pstmt->rtable = estate->es_range_table;
pstmt->resultRelations = NIL;
+ pstmt->rootResultRelations = NIL;
+ pstmt->appendRelations = NIL;
/*
* Transfer only parallel-safe subplans, leaving a NULL "hole" in the list
econtext = mtstate->ps.ps_ExprContext;
relationDesc = resultRelInfo->ri_RelationDesc->rd_att;
- /* carried forward solely for the benefit of explain */
- mtstate->mt_excludedtlist = node->exclRelTlist;
-
/* create state for DO UPDATE SET operation */
resultRelInfo->ri_onConflict = makeNode(OnConflictSetState);
COPY_NODE_FIELD(rtable);
COPY_NODE_FIELD(resultRelations);
COPY_NODE_FIELD(rootResultRelations);
+ COPY_NODE_FIELD(appendRelations);
COPY_NODE_FIELD(subplans);
COPY_BITMAPSET_FIELD(rewindPlanIDs);
COPY_NODE_FIELD(rowMarks);
/*
* copy remainder of node
*/
+ COPY_BITMAPSET_FIELD(apprelids);
COPY_NODE_FIELD(appendplans);
COPY_SCALAR_FIELD(first_partial_plan);
COPY_NODE_FIELD(part_prune_info);
/*
* copy remainder of node
*/
+ COPY_BITMAPSET_FIELD(apprelids);
COPY_NODE_FIELD(mergeplans);
COPY_SCALAR_FIELD(numCols);
COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber));
WRITE_NODE_FIELD(rtable);
WRITE_NODE_FIELD(resultRelations);
WRITE_NODE_FIELD(rootResultRelations);
+ WRITE_NODE_FIELD(appendRelations);
WRITE_NODE_FIELD(subplans);
WRITE_BITMAPSET_FIELD(rewindPlanIDs);
WRITE_NODE_FIELD(rowMarks);
_outPlanInfo(str, (const Plan *) node);
+ WRITE_BITMAPSET_FIELD(apprelids);
WRITE_NODE_FIELD(appendplans);
WRITE_INT_FIELD(first_partial_plan);
WRITE_NODE_FIELD(part_prune_info);
_outPlanInfo(str, (const Plan *) node);
+ WRITE_BITMAPSET_FIELD(apprelids);
WRITE_NODE_FIELD(mergeplans);
WRITE_INT_FIELD(numCols);
WRITE_ATTRNUMBER_ARRAY(sortColIdx, node->numCols);
WRITE_NODE_FIELD(finalrowmarks);
WRITE_NODE_FIELD(resultRelations);
WRITE_NODE_FIELD(rootResultRelations);
+ WRITE_NODE_FIELD(appendRelations);
WRITE_NODE_FIELD(relationOids);
WRITE_NODE_FIELD(invalItems);
WRITE_NODE_FIELD(paramExecTypes);
READ_NODE_FIELD(rtable);
READ_NODE_FIELD(resultRelations);
READ_NODE_FIELD(rootResultRelations);
+ READ_NODE_FIELD(appendRelations);
READ_NODE_FIELD(subplans);
READ_BITMAPSET_FIELD(rewindPlanIDs);
READ_NODE_FIELD(rowMarks);
ReadCommonPlan(&local_node->plan);
+ READ_BITMAPSET_FIELD(apprelids);
READ_NODE_FIELD(appendplans);
READ_INT_FIELD(first_partial_plan);
READ_NODE_FIELD(part_prune_info);
ReadCommonPlan(&local_node->plan);
+ READ_BITMAPSET_FIELD(apprelids);
READ_NODE_FIELD(mergeplans);
READ_INT_FIELD(numCols);
READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
plan->plan.qual = NIL;
plan->plan.lefttree = NULL;
plan->plan.righttree = NULL;
+ plan->apprelids = rel->relids;
if (pathkeys != NIL)
{
plan->qual = NIL;
plan->lefttree = NULL;
plan->righttree = NULL;
+ node->apprelids = rel->relids;
/*
* Compute sort column info, and adjust MergeAppend's tlist as needed.
glob->finalrowmarks = NIL;
glob->resultRelations = NIL;
glob->rootResultRelations = NIL;
+ glob->appendRelations = NIL;
glob->relationOids = NIL;
glob->invalItems = NIL;
glob->paramExecTypes = NIL;
Assert(glob->finalrowmarks == NIL);
Assert(glob->resultRelations == NIL);
Assert(glob->rootResultRelations == NIL);
+ Assert(glob->appendRelations == NIL);
top_plan = set_plan_references(root, top_plan);
/* ... and the subplans (both regular subplans and initplans) */
Assert(list_length(glob->subplans) == list_length(glob->subroots));
result->rtable = glob->finalrtable;
result->resultRelations = glob->resultRelations;
result->rootResultRelations = glob->rootResultRelations;
+ result->appendRelations = glob->appendRelations;
result->subplans = glob->subplans;
result->rewindPlanIDs = glob->rewindPlanIDs;
result->rowMarks = glob->finalrowmarks;
Index rootRelation = 0;
List *final_rtable = NIL;
List *final_rowmarks = NIL;
+ List *final_appendrels = NIL;
int save_rel_array_size = 0;
RelOptInfo **save_rel_array = NULL;
AppendRelInfo **save_append_rel_array = NULL;
* modified subquery RTEs into final_rtable, to ensure we have sane
* copies of those. Also save the first non-excluded child's version
* of the rowmarks list; we assume all children will end up with
- * equivalent versions of that.
+ * equivalent versions of that. Likewise for append_rel_list.
*/
if (final_rtable == NIL)
{
final_rtable = subroot->parse->rtable;
final_rowmarks = subroot->rowMarks;
+ final_appendrels = subroot->append_rel_list;
}
else
{
root->simple_rte_array[rti++] = rte;
}
- /* Put back adjusted rowmarks, too */
+ /* Put back adjusted rowmarks and appendrels, too */
root->rowMarks = final_rowmarks;
+ root->append_rel_list = final_appendrels;
}
/*
MergeAppend *mplan,
int rtoffset);
static void set_hash_references(PlannerInfo *root, Plan *plan, int rtoffset);
+static Relids offset_relid_set(Relids relids, int rtoffset);
static Node *fix_scan_expr(PlannerInfo *root, Node *node, int rtoffset);
static Node *fix_scan_expr_mutator(Node *node, fix_scan_expr_context *context);
static bool fix_scan_expr_walker(Node *node, fix_scan_expr_context *context);
*
* The flattened rangetable entries are appended to root->glob->finalrtable.
* Also, rowmarks entries are appended to root->glob->finalrowmarks, and the
- * RT indexes of ModifyTable result relations to root->glob->resultRelations.
+ * RT indexes of ModifyTable result relations to root->glob->resultRelations,
+ * and flattened AppendRelInfos are appended to root->glob->appendRelations.
* Plan dependencies are appended to root->glob->relationOids (for relations)
* and root->glob->invalItems (for everything else).
*
glob->finalrowmarks = lappend(glob->finalrowmarks, newrc);
}
+ /*
+ * Adjust RT indexes of AppendRelInfos and add to final appendrels list.
+ * We assume the AppendRelInfos were built during planning and don't need
+ * to be copied.
+ */
+ foreach(lc, root->append_rel_list)
+ {
+ AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
+
+ /* adjust RT indexes */
+ appinfo->parent_relid += rtoffset;
+ appinfo->child_relid += rtoffset;
+
+ /*
+ * Rather than adjust the translated_vars entries, just drop 'em.
+ * Neither the executor nor EXPLAIN currently need that data.
+ */
+ appinfo->translated_vars = NIL;
+
+ glob->appendRelations = lappend(glob->appendRelations, appinfo);
+ }
+
/* Now fix the Plan tree */
return set_plan_refs(root, plan, rtoffset);
}
fix_scan_list(root, fscan->fdw_recheck_quals, rtoffset);
}
- /* Adjust fs_relids if needed */
- if (rtoffset > 0)
- {
- Bitmapset *tempset = NULL;
- int x = -1;
-
- while ((x = bms_next_member(fscan->fs_relids, x)) >= 0)
- tempset = bms_add_member(tempset, x + rtoffset);
- fscan->fs_relids = tempset;
- }
+ fscan->fs_relids = offset_relid_set(fscan->fs_relids, rtoffset);
}
/*
lfirst(lc) = set_plan_refs(root, (Plan *) lfirst(lc), rtoffset);
}
- /* Adjust custom_relids if needed */
- if (rtoffset > 0)
- {
- Bitmapset *tempset = NULL;
- int x = -1;
-
- while ((x = bms_next_member(cscan->custom_relids, x)) >= 0)
- tempset = bms_add_member(tempset, x + rtoffset);
- cscan->custom_relids = tempset;
- }
+ cscan->custom_relids = offset_relid_set(cscan->custom_relids, rtoffset);
}
/*
*/
set_dummy_tlist_references((Plan *) aplan, rtoffset);
+ aplan->apprelids = offset_relid_set(aplan->apprelids, rtoffset);
+
if (aplan->part_prune_info)
{
foreach(l, aplan->part_prune_info->prune_infos)
*/
set_dummy_tlist_references((Plan *) mplan, rtoffset);
+ mplan->apprelids = offset_relid_set(mplan->apprelids, rtoffset);
+
if (mplan->part_prune_info)
{
foreach(l, mplan->part_prune_info->prune_infos)
Assert(plan->qual == NIL);
}
+/*
+ * offset_relid_set
+ * Apply rtoffset to the members of a Relids set.
+ */
+static Relids
+offset_relid_set(Relids relids, int rtoffset)
+{
+ Relids result = NULL;
+ int rtindex;
+
+ /* If there's no offset to apply, we needn't recompute the value */
+ if (rtoffset == 0)
+ return relids;
+ rtindex = -1;
+ while ((rtindex = bms_next_member(relids, rtindex)) >= 0)
+ result = bms_add_member(result, rtindex + rtoffset);
+ return result;
+}
+
/*
* copyVar
* Copy a Var node.
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
+#include "nodes/pathnodes.h"
#include "optimizer/optimizer.h"
#include "parser/parse_agg.h"
#include "parser/parse_func.h"
bool varprefix; /* true to print prefixes on Vars */
ParseExprKind special_exprkind; /* set only for exprkinds needing special
* handling */
+ Bitmapset *appendparents; /* if not null, map child Vars of these relids
+ * back to the parent rel */
} deparse_context;
/*
* A Var having varlevelsup=N refers to the N'th item (counting from 0) in
* the current context's namespaces list.
*
- * The rangetable is the list of actual RTEs from the query tree, and the
- * cte list is the list of actual CTEs.
- *
+ * rtable is the list of actual RTEs from the Query or PlannedStmt.
* rtable_names holds the alias name to be used for each RTE (either a C
* string, or NULL for nameless RTEs such as unnamed joins).
* rtable_columns holds the column alias names to be used for each RTE.
*
+ * subplans is a list of Plan trees for SubPlans and CTEs (it's only used
+ * in the PlannedStmt case).
+ * ctes is a list of CommonTableExpr nodes (only used in the Query case).
+ * appendrels, if not null (it's only used in the PlannedStmt case), is an
+ * array of AppendRelInfo nodes, indexed by child relid. We use that to map
+ * child-table Vars to their inheritance parents.
+ *
* In some cases we need to make names of merged JOIN USING columns unique
* across the whole query, not only per-RTE. If so, unique_using is true
* and using_names is a list of C strings representing names already assigned
*
* When deparsing plan trees, there is always just a single item in the
* deparse_namespace list (since a plan tree never contains Vars with
- * varlevelsup > 0). We store the PlanState node that is the immediate
+ * varlevelsup > 0). We store the Plan node that is the immediate
* parent of the expression to be deparsed, as well as a list of that
- * PlanState's ancestors. In addition, we store its outer and inner subplan
- * state nodes, as well as their plan nodes' targetlists, and the index tlist
- * if the current plan node might contain INDEX_VAR Vars. (These fields could
- * be derived on-the-fly from the current PlanState, but it seems notationally
- * clearer to set them up as separate fields.)
+ * Plan's ancestors. In addition, we store its outer and inner subplan nodes,
+ * as well as their targetlists, and the index tlist if the current plan node
+ * might contain INDEX_VAR Vars. (These fields could be derived on-the-fly
+ * from the current Plan node, but it seems notationally clearer to set them
+ * up as separate fields.)
*/
typedef struct
{
List *rtable; /* List of RangeTblEntry nodes */
List *rtable_names; /* Parallel list of names for RTEs */
List *rtable_columns; /* Parallel list of deparse_columns structs */
+ List *subplans; /* List of Plan trees for SubPlans */
List *ctes; /* List of CommonTableExpr nodes */
+ AppendRelInfo **appendrels; /* Array of AppendRelInfo nodes, or NULL */
/* Workspace for column alias assignment: */
bool unique_using; /* Are we making USING names globally unique */
List *using_names; /* List of assigned names for USING columns */
/* Remaining fields are used only when deparsing a Plan tree: */
- PlanState *planstate; /* immediate parent of current expression */
- List *ancestors; /* ancestors of planstate */
- PlanState *outer_planstate; /* outer subplan state, or NULL if none */
- PlanState *inner_planstate; /* inner subplan state, or NULL if none */
+ Plan *plan; /* immediate parent of current expression */
+ List *ancestors; /* ancestors of plan */
+ Plan *outer_plan; /* outer subnode, or NULL if none */
+ Plan *inner_plan; /* inner subnode, or NULL if none */
List *outer_tlist; /* referent for OUTER_VAR Vars */
List *inner_tlist; /* referent for INNER_VAR Vars */
List *index_tlist; /* referent for INDEX_VAR Vars */
int counter; /* Largest addition used so far for name */
} NameHashEntry;
+/* Callback signature for resolve_special_varno() */
+typedef void (*rsv_callback) (Node *node, deparse_context *context,
+ void *callback_arg);
+
/* ----------
* Global data
static void flatten_join_using_qual(Node *qual,
List **leftvars, List **rightvars);
static char *get_rtable_name(int rtindex, deparse_context *context);
-static void set_deparse_planstate(deparse_namespace *dpns, PlanState *ps);
-static void push_child_plan(deparse_namespace *dpns, PlanState *ps,
+static void set_deparse_plan(deparse_namespace *dpns, Plan *plan);
+static void push_child_plan(deparse_namespace *dpns, Plan *plan,
deparse_namespace *save_dpns);
static void pop_child_plan(deparse_namespace *dpns,
deparse_namespace *save_dpns);
static char *get_variable(Var *var, int levelsup, bool istoplevel,
deparse_context *context);
static void get_special_variable(Node *node, deparse_context *context,
- void *private);
+ void *callback_arg);
static void resolve_special_varno(Node *node, deparse_context *context,
- void *private,
- void (*callback) (Node *, deparse_context *, void *));
+ rsv_callback callback, void *callback_arg);
static Node *find_param_referent(Param *param, deparse_context *context,
deparse_namespace **dpns_p, ListCell **ancestor_cell_p);
static void get_parameter(Param *param, deparse_context *context);
static void get_agg_expr(Aggref *aggref, deparse_context *context,
Aggref *original_aggref);
static void get_agg_combine_expr(Node *node, deparse_context *context,
- void *private);
+ void *callback_arg);
static void get_windowfunc_expr(WindowFunc *wfunc, deparse_context *context);
static void get_coercion_expr(Node *arg, deparse_context *context,
Oid resulttype, int32 resulttypmod,
/* Build two-element rtable */
memset(&dpns, 0, sizeof(dpns));
dpns.rtable = list_make2(oldrte, newrte);
+ dpns.subplans = NIL;
dpns.ctes = NIL;
+ dpns.appendrels = NULL;
set_rtable_names(&dpns, NIL, NULL);
set_simple_column_names(&dpns);
context.wrapColumn = WRAP_COLUMN_DEFAULT;
context.indentLevel = PRETTYINDENT_STD;
context.special_exprkind = EXPR_KIND_NONE;
+ context.appendparents = NULL;
get_rule_expr(qual, &context, false);
context.wrapColumn = WRAP_COLUMN_DEFAULT;
context.indentLevel = startIndent;
context.special_exprkind = EXPR_KIND_NONE;
+ context.appendparents = NULL;
get_rule_expr(expr, &context, showimplicit);
/* Build one-element rtable */
dpns->rtable = list_make1(rte);
+ dpns->subplans = NIL;
dpns->ctes = NIL;
+ dpns->appendrels = NULL;
set_rtable_names(dpns, NIL, NULL);
set_simple_column_names(dpns);
}
/*
- * deparse_context_for_plan_rtable - Build deparse context for a plan's rtable
+ * deparse_context_for_plan_tree - Build deparse context for a Plan tree
*
* When deparsing an expression in a Plan tree, we use the plan's rangetable
* to resolve names of simple Vars. The initialization of column names for
* this is rather expensive if the rangetable is large, and it'll be the same
* for every expression in the Plan tree; so we do it just once and re-use
* the result of this function for each expression. (Note that the result
- * is not usable until set_deparse_context_planstate() is applied to it.)
+ * is not usable until set_deparse_context_plan() is applied to it.)
*
- * In addition to the plan's rangetable list, pass the per-RTE alias names
+ * In addition to the PlannedStmt, pass the per-RTE alias names
* assigned by a previous call to select_rtable_names_for_explain.
*/
List *
-deparse_context_for_plan_rtable(List *rtable, List *rtable_names)
+deparse_context_for_plan_tree(PlannedStmt *pstmt, List *rtable_names)
{
deparse_namespace *dpns;
dpns = (deparse_namespace *) palloc0(sizeof(deparse_namespace));
/* Initialize fields that stay the same across the whole plan tree */
- dpns->rtable = rtable;
+ dpns->rtable = pstmt->rtable;
dpns->rtable_names = rtable_names;
+ dpns->subplans = pstmt->subplans;
dpns->ctes = NIL;
+ if (pstmt->appendRelations)
+ {
+ /* Set up the array, indexed by child relid */
+ int ntables = list_length(dpns->rtable);
+ ListCell *lc;
+
+ dpns->appendrels = (AppendRelInfo **)
+ palloc0((ntables + 1) * sizeof(AppendRelInfo *));
+ foreach(lc, pstmt->appendRelations)
+ {
+ AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
+ Index crelid = appinfo->child_relid;
+
+ Assert(crelid > 0 && crelid <= ntables);
+ Assert(dpns->appendrels[crelid] == NULL);
+ dpns->appendrels[crelid] = appinfo;
+ }
+ }
+ else
+ dpns->appendrels = NULL; /* don't need it */
/*
* Set up column name aliases. We will get rather bogus results for join
}
/*
- * set_deparse_context_planstate - Specify Plan node containing expression
+ * set_deparse_context_plan - Specify Plan node containing expression
*
* When deparsing an expression in a Plan tree, we might have to resolve
* OUTER_VAR, INNER_VAR, or INDEX_VAR references. To do this, the caller must
- * provide the parent PlanState node. Then OUTER_VAR and INNER_VAR references
+ * provide the parent Plan node. Then OUTER_VAR and INNER_VAR references
* can be resolved by drilling down into the left and right child plans.
* Similarly, INDEX_VAR references can be resolved by reference to the
* indextlist given in a parent IndexOnlyScan node, or to the scan tlist in
* for those, we can only deparse the indexqualorig fields, which won't
* contain INDEX_VAR Vars.)
*
- * Note: planstate really ought to be declared as "PlanState *", but we use
- * "Node *" to avoid having to include execnodes.h in ruleutils.h.
- *
- * The ancestors list is a list of the PlanState's parent PlanStates, the
- * most-closely-nested first. This is needed to resolve PARAM_EXEC Params.
- * Note we assume that all the PlanStates share the same rtable.
+ * The ancestors list is a list of the Plan's parent Plan and SubPlan nodes,
+ * the most-closely-nested first. This is needed to resolve PARAM_EXEC
+ * Params. Note we assume that all the Plan nodes share the same rtable.
*
* Once this function has been called, deparse_expression() can be called on
- * subsidiary expression(s) of the specified PlanState node. To deparse
+ * subsidiary expression(s) of the specified Plan node. To deparse
* expressions of a different Plan node in the same Plan tree, re-call this
* function to identify the new parent Plan node.
*
* The result is the same List passed in; this is a notational convenience.
*/
List *
-set_deparse_context_planstate(List *dpcontext,
- Node *planstate, List *ancestors)
+set_deparse_context_plan(List *dpcontext, Plan *plan, List *ancestors)
{
deparse_namespace *dpns;
dpns = (deparse_namespace *) linitial(dpcontext);
/* Set our attention on the specific plan node passed in */
- set_deparse_planstate(dpns, (PlanState *) planstate);
+ set_deparse_plan(dpns, plan);
dpns->ancestors = ancestors;
return dpcontext;
memset(&dpns, 0, sizeof(dpns));
dpns.rtable = rtable;
+ dpns.subplans = NIL;
dpns.ctes = NIL;
+ dpns.appendrels = NULL;
set_rtable_names(&dpns, NIL, rels_used);
/* We needn't bother computing column aliases yet */
/* Initialize *dpns and fill rtable/ctes links */
memset(dpns, 0, sizeof(deparse_namespace));
dpns->rtable = query->rtable;
+ dpns->subplans = NIL;
dpns->ctes = query->cteList;
+ dpns->appendrels = NULL;
/* Assign a unique relation alias to each RTE */
set_rtable_names(dpns, parent_namespaces, NULL);
}
/*
- * set_deparse_planstate: set up deparse_namespace to parse subexpressions
- * of a given PlanState node
+ * set_deparse_plan: set up deparse_namespace to parse subexpressions
+ * of a given Plan node
*
- * This sets the planstate, outer_planstate, inner_planstate, outer_tlist,
- * inner_tlist, and index_tlist fields. Caller is responsible for adjusting
- * the ancestors list if necessary. Note that the rtable and ctes fields do
+ * This sets the plan, outer_plan, inner_plan, outer_tlist, inner_tlist,
+ * and index_tlist fields. Caller is responsible for adjusting the ancestors
+ * list if necessary. Note that the rtable, subplans, and ctes fields do
* not need to change when shifting attention to different plan nodes in a
* single plan tree.
*/
static void
-set_deparse_planstate(deparse_namespace *dpns, PlanState *ps)
+set_deparse_plan(deparse_namespace *dpns, Plan *plan)
{
- dpns->planstate = ps;
+ dpns->plan = plan;
/*
* We special-case Append and MergeAppend to pretend that the first child
* first child plan is the OUTER referent; this is to support RETURNING
* lists containing references to non-target relations.
*/
- if (IsA(ps, AppendState))
- dpns->outer_planstate = ((AppendState *) ps)->appendplans[0];
- else if (IsA(ps, MergeAppendState))
- dpns->outer_planstate = ((MergeAppendState *) ps)->mergeplans[0];
- else if (IsA(ps, ModifyTableState))
- dpns->outer_planstate = ((ModifyTableState *) ps)->mt_plans[0];
+ if (IsA(plan, Append))
+ dpns->outer_plan = linitial(((Append *) plan)->appendplans);
+ else if (IsA(plan, MergeAppend))
+ dpns->outer_plan = linitial(((MergeAppend *) plan)->mergeplans);
+ else if (IsA(plan, ModifyTable))
+ dpns->outer_plan = linitial(((ModifyTable *) plan)->plans);
else
- dpns->outer_planstate = outerPlanState(ps);
+ dpns->outer_plan = outerPlan(plan);
- if (dpns->outer_planstate)
- dpns->outer_tlist = dpns->outer_planstate->plan->targetlist;
+ if (dpns->outer_plan)
+ dpns->outer_tlist = dpns->outer_plan->targetlist;
else
dpns->outer_tlist = NIL;
* to reuse OUTER, it's used for RETURNING in some modify table cases,
* although not INSERT .. CONFLICT).
*/
- if (IsA(ps, SubqueryScanState))
- dpns->inner_planstate = ((SubqueryScanState *) ps)->subplan;
- else if (IsA(ps, CteScanState))
- dpns->inner_planstate = ((CteScanState *) ps)->cteplanstate;
- else if (IsA(ps, ModifyTableState))
- dpns->inner_planstate = ps;
+ if (IsA(plan, SubqueryScan))
+ dpns->inner_plan = ((SubqueryScan *) plan)->subplan;
+ else if (IsA(plan, CteScan))
+ dpns->inner_plan = list_nth(dpns->subplans,
+ ((CteScan *) plan)->ctePlanId - 1);
+ else if (IsA(plan, ModifyTable))
+ dpns->inner_plan = plan;
else
- dpns->inner_planstate = innerPlanState(ps);
+ dpns->inner_plan = innerPlan(plan);
- if (IsA(ps, ModifyTableState))
- dpns->inner_tlist = ((ModifyTableState *) ps)->mt_excludedtlist;
- else if (dpns->inner_planstate)
- dpns->inner_tlist = dpns->inner_planstate->plan->targetlist;
+ if (IsA(plan, ModifyTable))
+ dpns->inner_tlist = ((ModifyTable *) plan)->exclRelTlist;
+ else if (dpns->inner_plan)
+ dpns->inner_tlist = dpns->inner_plan->targetlist;
else
dpns->inner_tlist = NIL;
/* Set up referent for INDEX_VAR Vars, if needed */
- if (IsA(ps->plan, IndexOnlyScan))
- dpns->index_tlist = ((IndexOnlyScan *) ps->plan)->indextlist;
- else if (IsA(ps->plan, ForeignScan))
- dpns->index_tlist = ((ForeignScan *) ps->plan)->fdw_scan_tlist;
- else if (IsA(ps->plan, CustomScan))
- dpns->index_tlist = ((CustomScan *) ps->plan)->custom_scan_tlist;
+ if (IsA(plan, IndexOnlyScan))
+ dpns->index_tlist = ((IndexOnlyScan *) plan)->indextlist;
+ else if (IsA(plan, ForeignScan))
+ dpns->index_tlist = ((ForeignScan *) plan)->fdw_scan_tlist;
+ else if (IsA(plan, CustomScan))
+ dpns->index_tlist = ((CustomScan *) plan)->custom_scan_tlist;
else
dpns->index_tlist = NIL;
}
* previous state for pop_child_plan.
*/
static void
-push_child_plan(deparse_namespace *dpns, PlanState *ps,
+push_child_plan(deparse_namespace *dpns, Plan *plan,
deparse_namespace *save_dpns)
{
/* Save state for restoration later */
*save_dpns = *dpns;
/* Link current plan node into ancestors list */
- dpns->ancestors = lcons(dpns->planstate, dpns->ancestors);
+ dpns->ancestors = lcons(dpns->plan, dpns->ancestors);
/* Set attention on selected child */
- set_deparse_planstate(dpns, ps);
+ set_deparse_plan(dpns, plan);
}
/*
push_ancestor_plan(deparse_namespace *dpns, ListCell *ancestor_cell,
deparse_namespace *save_dpns)
{
- PlanState *ps = (PlanState *) lfirst(ancestor_cell);
+ Plan *plan = (Plan *) lfirst(ancestor_cell);
/* Save state for restoration later */
*save_dpns = *dpns;
list_cell_number(dpns->ancestors, ancestor_cell) + 1);
/* Set attention on selected ancestor */
- set_deparse_planstate(dpns, ps);
+ set_deparse_plan(dpns, plan);
}
/*
context.wrapColumn = WRAP_COLUMN_DEFAULT;
context.indentLevel = PRETTYINDENT_STD;
context.special_exprkind = EXPR_KIND_NONE;
+ context.appendparents = NULL;
set_deparse_for_query(&dpns, query, NIL);
context.wrapColumn = wrapColumn;
context.indentLevel = startIndent;
context.special_exprkind = EXPR_KIND_NONE;
+ context.appendparents = NULL;
set_deparse_for_query(&dpns, query, parentnamespace);
*/
if (var->varno >= 1 && var->varno <= list_length(dpns->rtable))
{
- rte = rt_fetch(var->varno, dpns->rtable);
- refname = (char *) list_nth(dpns->rtable_names, var->varno - 1);
- colinfo = deparse_columns_fetch(var->varno, dpns);
- attnum = var->varattno;
+ Index varno = var->varno;
+ AttrNumber varattno = var->varattno;
+
+ /*
+ * We might have been asked to map child Vars to some parent relation.
+ */
+ if (context->appendparents && dpns->appendrels)
+ {
+ Index pvarno = varno;
+ AttrNumber pvarattno = varattno;
+ AppendRelInfo *appinfo = dpns->appendrels[pvarno];
+ bool found = false;
+
+ /* Only map up to inheritance parents, not UNION ALL appendrels */
+ while (appinfo &&
+ rt_fetch(appinfo->parent_relid,
+ dpns->rtable)->rtekind == RTE_RELATION)
+ {
+ found = false;
+ if (pvarattno > 0) /* system columns stay as-is */
+ {
+ if (pvarattno > appinfo->num_child_cols)
+ break; /* safety check */
+ pvarattno = appinfo->parent_colnos[pvarattno - 1];
+ if (pvarattno == 0)
+ break; /* Var is local to child */
+ }
+
+ pvarno = appinfo->parent_relid;
+ found = true;
+
+ /* If the parent is itself a child, continue up. */
+ Assert(pvarno > 0 && pvarno <= list_length(dpns->rtable));
+ appinfo = dpns->appendrels[pvarno];
+ }
+
+ /*
+ * If we found an ancestral rel, and that rel is included in
+ * appendparents, print that column not the original one.
+ */
+ if (found && bms_is_member(pvarno, context->appendparents))
+ {
+ varno = pvarno;
+ varattno = pvarattno;
+ }
+ }
+
+ rte = rt_fetch(varno, dpns->rtable);
+ refname = (char *) list_nth(dpns->rtable_names, varno - 1);
+ colinfo = deparse_columns_fetch(varno, dpns);
+ attnum = varattno;
}
else
{
- resolve_special_varno((Node *) var, context, NULL,
- get_special_variable);
+ resolve_special_varno((Node *) var, context,
+ get_special_variable, NULL);
return NULL;
}
* no alias. So in that case, drill down to the subplan and print the
* contents of the referenced tlist item. This works because in a plan
* tree, such Vars can only occur in a SubqueryScan or CteScan node, and
- * we'll have set dpns->inner_planstate to reference the child plan node.
+ * we'll have set dpns->inner_plan to reference the child plan node.
*/
if ((rte->rtekind == RTE_SUBQUERY || rte->rtekind == RTE_CTE) &&
attnum > list_length(rte->eref->colnames) &&
- dpns->inner_planstate)
+ dpns->inner_plan)
{
TargetEntry *tle;
deparse_namespace save_dpns;
- tle = get_tle_by_resno(dpns->inner_tlist, var->varattno);
+ tle = get_tle_by_resno(dpns->inner_tlist, attnum);
if (!tle)
elog(ERROR, "invalid attnum %d for relation \"%s\"",
- var->varattno, rte->eref->aliasname);
+ attnum, rte->eref->aliasname);
Assert(netlevelsup == 0);
- push_child_plan(dpns, dpns->inner_planstate, &save_dpns);
+ push_child_plan(dpns, dpns->inner_plan, &save_dpns);
/*
* Force parentheses because our caller probably assumed a Var is a
* get_rule_expr.
*/
static void
-get_special_variable(Node *node, deparse_context *context, void *private)
+get_special_variable(Node *node, deparse_context *context, void *callback_arg)
{
StringInfo buf = context->buf;
/*
- * Force parentheses because our caller probably assumed a Var is a simple
- * expression.
+ * For a non-Var referent, force parentheses because our caller probably
+ * assumed a Var is a simple expression.
*/
if (!IsA(node, Var))
appendStringInfoChar(buf, '(');
* invoke the callback provided.
*/
static void
-resolve_special_varno(Node *node, deparse_context *context, void *private,
- void (*callback) (Node *, deparse_context *, void *))
+resolve_special_varno(Node *node, deparse_context *context,
+ rsv_callback callback, void *callback_arg)
{
Var *var;
deparse_namespace *dpns;
+ /* This function is recursive, so let's be paranoid. */
+ check_stack_depth();
+
/* If it's not a Var, invoke the callback. */
if (!IsA(node, Var))
{
- callback(node, context, private);
+ (*callback) (node, context, callback_arg);
return;
}
var->varlevelsup);
/*
- * It's a special RTE, so recurse.
+ * If varno is special, recurse.
*/
if (var->varno == OUTER_VAR && dpns->outer_tlist)
{
TargetEntry *tle;
deparse_namespace save_dpns;
+ Bitmapset *save_appendparents;
tle = get_tle_by_resno(dpns->outer_tlist, var->varattno);
if (!tle)
elog(ERROR, "bogus varattno for OUTER_VAR var: %d", var->varattno);
- push_child_plan(dpns, dpns->outer_planstate, &save_dpns);
- resolve_special_varno((Node *) tle->expr, context, private, callback);
+ /*
+ * If we're descending to the first child of an Append or MergeAppend,
+ * update appendparents. This will affect deparsing of all Vars
+ * appearing within the eventually-resolved subexpression.
+ */
+ save_appendparents = context->appendparents;
+
+ if (IsA(dpns->plan, Append))
+ context->appendparents = bms_union(context->appendparents,
+ ((Append *) dpns->plan)->apprelids);
+ else if (IsA(dpns->plan, MergeAppend))
+ context->appendparents = bms_union(context->appendparents,
+ ((MergeAppend *) dpns->plan)->apprelids);
+
+ push_child_plan(dpns, dpns->outer_plan, &save_dpns);
+ resolve_special_varno((Node *) tle->expr, context,
+ callback, callback_arg);
pop_child_plan(dpns, &save_dpns);
+ context->appendparents = save_appendparents;
return;
}
else if (var->varno == INNER_VAR && dpns->inner_tlist)
if (!tle)
elog(ERROR, "bogus varattno for INNER_VAR var: %d", var->varattno);
- push_child_plan(dpns, dpns->inner_planstate, &save_dpns);
- resolve_special_varno((Node *) tle->expr, context, private, callback);
+ push_child_plan(dpns, dpns->inner_plan, &save_dpns);
+ resolve_special_varno((Node *) tle->expr, context,
+ callback, callback_arg);
pop_child_plan(dpns, &save_dpns);
return;
}
if (!tle)
elog(ERROR, "bogus varattno for INDEX_VAR var: %d", var->varattno);
- resolve_special_varno((Node *) tle->expr, context, private, callback);
+ resolve_special_varno((Node *) tle->expr, context,
+ callback, callback_arg);
return;
}
else if (var->varno < 1 || var->varno > list_length(dpns->rtable))
elog(ERROR, "bogus varno: %d", var->varno);
/* Not special. Just invoke the callback. */
- callback(node, context, private);
+ (*callback) (node, context, callback_arg);
}
/*
* Try to find the relevant RTE in this rtable. In a plan tree, it's
* likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
* down into the subplans, or INDEX_VAR, which is resolved similarly.
+ *
+ * Note: unlike get_variable and resolve_special_varno, we need not worry
+ * about inheritance mapping: a child Var should have the same datatype as
+ * its parent, and here we're really only interested in the Var's type.
*/
if (var->varno >= 1 && var->varno <= list_length(dpns->rtable))
{
elog(ERROR, "bogus varattno for OUTER_VAR var: %d", var->varattno);
Assert(netlevelsup == 0);
- push_child_plan(dpns, dpns->outer_planstate, &save_dpns);
+ push_child_plan(dpns, dpns->outer_plan, &save_dpns);
result = get_name_for_var_field((Var *) tle->expr, fieldno,
levelsup, context);
elog(ERROR, "bogus varattno for INNER_VAR var: %d", var->varattno);
Assert(netlevelsup == 0);
- push_child_plan(dpns, dpns->inner_planstate, &save_dpns);
+ push_child_plan(dpns, dpns->inner_plan, &save_dpns);
result = get_name_for_var_field((Var *) tle->expr, fieldno,
levelsup, context);
deparse_namespace save_dpns;
const char *result;
- if (!dpns->inner_planstate)
+ if (!dpns->inner_plan)
elog(ERROR, "failed to find plan for subquery %s",
rte->eref->aliasname);
tle = get_tle_by_resno(dpns->inner_tlist, attnum);
elog(ERROR, "bogus varattno for subquery var: %d",
attnum);
Assert(netlevelsup == 0);
- push_child_plan(dpns, dpns->inner_planstate, &save_dpns);
+ push_child_plan(dpns, dpns->inner_plan, &save_dpns);
result = get_name_for_var_field((Var *) tle->expr, fieldno,
levelsup, context);
deparse_namespace save_dpns;
const char *result;
- if (!dpns->inner_planstate)
+ if (!dpns->inner_plan)
elog(ERROR, "failed to find plan for CTE %s",
rte->eref->aliasname);
tle = get_tle_by_resno(dpns->inner_tlist, attnum);
elog(ERROR, "bogus varattno for subquery var: %d",
attnum);
Assert(netlevelsup == 0);
- push_child_plan(dpns, dpns->inner_planstate, &save_dpns);
+ push_child_plan(dpns, dpns->inner_plan, &save_dpns);
result = get_name_for_var_field((Var *) tle->expr, fieldno,
levelsup, context);
/*
* If it's a PARAM_EXEC parameter, look for a matching NestLoopParam or
* SubPlan argument. This will necessarily be in some ancestor of the
- * current expression's PlanState.
+ * current expression's Plan node.
*/
if (param->paramkind == PARAM_EXEC)
{
deparse_namespace *dpns;
- PlanState *child_ps;
+ Plan *child_plan;
bool in_same_plan_level;
ListCell *lc;
dpns = (deparse_namespace *) linitial(context->namespaces);
- child_ps = dpns->planstate;
+ child_plan = dpns->plan;
in_same_plan_level = true;
foreach(lc, dpns->ancestors)
{
- PlanState *ps = (PlanState *) lfirst(lc);
+ Node *ancestor = (Node *) lfirst(lc);
ListCell *lc2;
/*
* we've crawled up out of a subplan, this couldn't possibly be
* the right match.
*/
- if (IsA(ps, NestLoopState) &&
- child_ps == innerPlanState(ps) &&
+ if (IsA(ancestor, NestLoop) &&
+ child_plan == innerPlan(ancestor) &&
in_same_plan_level)
{
- NestLoop *nl = (NestLoop *) ps->plan;
+ NestLoop *nl = (NestLoop *) ancestor;
foreach(lc2, nl->nestParams)
{
}
/*
- * Check to see if we're crawling up from a subplan.
+ * If ancestor is a SubPlan, check the arguments it provides.
*/
- foreach(lc2, ps->subPlan)
+ if (IsA(ancestor, SubPlan))
{
- SubPlanState *sstate = (SubPlanState *) lfirst(lc2);
- SubPlan *subplan = sstate->subplan;
+ SubPlan *subplan = (SubPlan *) ancestor;
ListCell *lc3;
ListCell *lc4;
- if (child_ps != sstate->planstate)
- continue;
-
- /* Matched subplan, so check its arguments */
forboth(lc3, subplan->parParam, lc4, subplan->args)
{
int paramid = lfirst_int(lc3);
if (paramid == param->paramid)
{
- /* Found a match, so return it */
- *dpns_p = dpns;
- *ancestor_cell_p = lc;
- return arg;
+ /*
+ * Found a match, so return it. But, since Vars in
+ * the arg are to be evaluated in the surrounding
+ * context, we have to point to the next ancestor item
+ * that is *not* a SubPlan.
+ */
+ ListCell *rest;
+
+ for_each_cell(rest, dpns->ancestors,
+ lnext(dpns->ancestors, lc))
+ {
+ Node *ancestor2 = (Node *) lfirst(rest);
+
+ if (!IsA(ancestor2, SubPlan))
+ {
+ *dpns_p = dpns;
+ *ancestor_cell_p = rest;
+ return arg;
+ }
+ }
+ elog(ERROR, "SubPlan cannot be outermost ancestor");
}
}
- /* Keep looking, but we are emerging from a subplan. */
+ /* We have emerged from a subplan. */
in_same_plan_level = false;
- break;
+
+ /* SubPlan isn't a kind of Plan, so skip the rest */
+ continue;
}
/*
- * Likewise check to see if we're emerging from an initplan.
- * Initplans never have any parParams, so no need to search that
- * list, but we need to know if we should reset
+ * Check to see if we're emerging from an initplan of the current
+ * ancestor plan. Initplans never have any parParams, so no need
+ * to search that list, but we need to know if we should reset
* in_same_plan_level.
*/
- foreach(lc2, ps->initPlan)
+ foreach(lc2, ((Plan *) ancestor)->initPlan)
{
- SubPlanState *sstate = (SubPlanState *) lfirst(lc2);
+ SubPlan *subplan = castNode(SubPlan, lfirst(lc2));
- if (child_ps != sstate->planstate)
+ if (child_plan != (Plan *) list_nth(dpns->subplans,
+ subplan->plan_id - 1))
continue;
/* No parameters to be had here. */
- Assert(sstate->subplan->parParam == NIL);
+ Assert(subplan->parParam == NIL);
- /* Keep looking, but we are emerging from an initplan. */
+ /* We have emerged from an initplan. */
in_same_plan_level = false;
break;
}
/* No luck, crawl up to next ancestor */
- child_ps = ps;
+ child_plan = (Plan *) ancestor;
}
}
*/
if (DO_AGGSPLIT_COMBINE(aggref->aggsplit))
{
- TargetEntry *tle = linitial_node(TargetEntry, aggref->args);
+ TargetEntry *tle;
Assert(list_length(aggref->args) == 1);
- resolve_special_varno((Node *) tle->expr, context, original_aggref,
- get_agg_combine_expr);
+ tle = linitial_node(TargetEntry, aggref->args);
+ resolve_special_varno((Node *) tle->expr, context,
+ get_agg_combine_expr, original_aggref);
return;
}
* Aggref and then calls this.
*/
static void
-get_agg_combine_expr(Node *node, deparse_context *context, void *private)
+get_agg_combine_expr(Node *node, deparse_context *context, void *callback_arg)
{
Aggref *aggref;
- Aggref *original_aggref = private;
+ Aggref *original_aggref = callback_arg;
if (!IsA(node, Aggref))
elog(ERROR, "combining Aggref does not point to an Aggref");
List **mt_arowmarks; /* per-subplan ExecAuxRowMark lists */
EPQState mt_epqstate; /* for evaluating EvalPlanQual rechecks */
bool fireBSTriggers; /* do we need to fire stmt triggers? */
- List *mt_excludedtlist; /* the excluded pseudo relation's tlist */
/*
* Slot for storing tuples in the root partitioned table's rowtype during
List *rootResultRelations; /* "flat" list of integer RT indexes */
+ List *appendRelations; /* "flat" list of AppendRelInfos */
+
List *relationOids; /* OIDs of relations the plan depends on */
List *invalItems; /* other dependencies, as PlanInvalItems */
*/
List *rootResultRelations;
+ List *appendRelations; /* list of AppendRelInfo nodes */
+
List *subplans; /* Plan trees for SubPlan expressions; note
* that some could be NULL */
typedef struct Append
{
Plan plan;
+ Bitmapset *apprelids; /* RTIs of appendrel(s) formed by this node */
List *appendplans;
/*
typedef struct MergeAppend
{
Plan plan;
+ Bitmapset *apprelids; /* RTIs of appendrel(s) formed by this node */
List *mergeplans;
/* these fields are just like the sort-key info in struct Sort: */
int numCols; /* number of sort-key columns */
#include "nodes/parsenodes.h"
#include "nodes/pg_list.h"
+struct Plan; /* avoid including plannodes.h here */
+struct PlannedStmt;
+
extern char *pg_get_indexdef_string(Oid indexrelid);
extern char *pg_get_indexdef_columns(Oid indexrelid, bool pretty);
extern char *deparse_expression(Node *expr, List *dpcontext,
bool forceprefix, bool showimplicit);
extern List *deparse_context_for(const char *aliasname, Oid relid);
-extern List *deparse_context_for_plan_rtable(List *rtable, List *rtable_names);
-extern List *set_deparse_context_planstate(List *dpcontext,
- Node *planstate, List *ancestors);
+extern List *deparse_context_for_plan_tree(struct PlannedStmt *pstmt,
+ List *rtable_names);
+extern List *set_deparse_context_plan(List *dpcontext,
+ struct Plan *plan, List *ancestors);
extern List *select_rtable_names_for_explain(List *rtable,
Bitmapset *rels_used);
extern char *generate_collation_name(Oid collid);
-> Limit
-> Merge Append
Sort Key: minmaxtest.f1
- -> Index Only Scan using minmaxtesti on minmaxtest
+ -> Index Only Scan using minmaxtesti on minmaxtest minmaxtest_1
Index Cond: (f1 IS NOT NULL)
- -> Index Only Scan using minmaxtest1i on minmaxtest1 minmaxtest_1
+ -> Index Only Scan using minmaxtest1i on minmaxtest1 minmaxtest_2
Index Cond: (f1 IS NOT NULL)
- -> Index Only Scan Backward using minmaxtest2i on minmaxtest2 minmaxtest_2
+ -> Index Only Scan Backward using minmaxtest2i on minmaxtest2 minmaxtest_3
Index Cond: (f1 IS NOT NULL)
- -> Index Only Scan using minmaxtest3i on minmaxtest3 minmaxtest_3
+ -> Index Only Scan using minmaxtest3i on minmaxtest3 minmaxtest_4
InitPlan 2 (returns $1)
-> Limit
-> Merge Append
- Sort Key: minmaxtest_4.f1 DESC
- -> Index Only Scan Backward using minmaxtesti on minmaxtest minmaxtest_4
+ Sort Key: minmaxtest_5.f1 DESC
+ -> Index Only Scan Backward using minmaxtesti on minmaxtest minmaxtest_6
Index Cond: (f1 IS NOT NULL)
- -> Index Only Scan Backward using minmaxtest1i on minmaxtest1 minmaxtest_5
+ -> Index Only Scan Backward using minmaxtest1i on minmaxtest1 minmaxtest_7
Index Cond: (f1 IS NOT NULL)
- -> Index Only Scan using minmaxtest2i on minmaxtest2 minmaxtest_6
+ -> Index Only Scan using minmaxtest2i on minmaxtest2 minmaxtest_8
Index Cond: (f1 IS NOT NULL)
- -> Index Only Scan Backward using minmaxtest3i on minmaxtest3 minmaxtest_7
+ -> Index Only Scan Backward using minmaxtest3i on minmaxtest3 minmaxtest_9
(23 rows)
select min(f1), max(f1) from minmaxtest;
-> Limit
-> Merge Append
Sort Key: minmaxtest.f1
- -> Index Only Scan using minmaxtesti on minmaxtest
+ -> Index Only Scan using minmaxtesti on minmaxtest minmaxtest_1
Index Cond: (f1 IS NOT NULL)
- -> Index Only Scan using minmaxtest1i on minmaxtest1 minmaxtest_1
+ -> Index Only Scan using minmaxtest1i on minmaxtest1 minmaxtest_2
Index Cond: (f1 IS NOT NULL)
- -> Index Only Scan Backward using minmaxtest2i on minmaxtest2 minmaxtest_2
+ -> Index Only Scan Backward using minmaxtest2i on minmaxtest2 minmaxtest_3
Index Cond: (f1 IS NOT NULL)
- -> Index Only Scan using minmaxtest3i on minmaxtest3 minmaxtest_3
+ -> Index Only Scan using minmaxtest3i on minmaxtest3 minmaxtest_4
InitPlan 2 (returns $1)
-> Limit
-> Merge Append
- Sort Key: minmaxtest_4.f1 DESC
- -> Index Only Scan Backward using minmaxtesti on minmaxtest minmaxtest_4
+ Sort Key: minmaxtest_5.f1 DESC
+ -> Index Only Scan Backward using minmaxtesti on minmaxtest minmaxtest_6
Index Cond: (f1 IS NOT NULL)
- -> Index Only Scan Backward using minmaxtest1i on minmaxtest1 minmaxtest_5
+ -> Index Only Scan Backward using minmaxtest1i on minmaxtest1 minmaxtest_7
Index Cond: (f1 IS NOT NULL)
- -> Index Only Scan using minmaxtest2i on minmaxtest2 minmaxtest_6
+ -> Index Only Scan using minmaxtest2i on minmaxtest2 minmaxtest_8
Index Cond: (f1 IS NOT NULL)
- -> Index Only Scan Backward using minmaxtest3i on minmaxtest3 minmaxtest_7
+ -> Index Only Scan Backward using minmaxtest3i on minmaxtest3 minmaxtest_9
-> Sort
Sort Key: ($0), ($1)
-> Result
HashAggregate
Group Key: t1.a, t1.b, t1.c, t1.d
-> Append
- -> Seq Scan on t1
- -> Seq Scan on t1c t1_1
+ -> Seq Scan on t1 t1_1
+ -> Seq Scan on t1c t1_2
(5 rows)
-- Okay to remove columns if we're only querying the parent.
create temp table p_t1_2 partition of p_t1 for values in(2);
-- Ensure we can remove non-PK columns for partitioned tables.
explain (costs off) select * from p_t1 group by a,b,c,d;
- QUERY PLAN
----------------------------------------
+ QUERY PLAN
+--------------------------------
HashAggregate
Group Key: p_t1.a, p_t1.b
-> Append
- -> Seq Scan on p_t1_1 p_t1
- -> Seq Scan on p_t1_2 p_t1_1
+ -> Seq Scan on p_t1_1
+ -> Seq Scan on p_t1_2
(5 rows)
drop table t1 cascade;
QUERY PLAN
---------------------------------------------------------------------------
Append
- -> Seq Scan on nv_parent
+ -> Seq Scan on nv_parent nv_parent_1
Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
- -> Seq Scan on nv_child_2010 nv_parent_1
+ -> Seq Scan on nv_child_2010 nv_parent_2
Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
- -> Seq Scan on nv_child_2011 nv_parent_2
+ -> Seq Scan on nv_child_2011 nv_parent_3
Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
(7 rows)
QUERY PLAN
---------------------------------------------------------------------------
Append
- -> Seq Scan on nv_parent
+ -> Seq Scan on nv_parent nv_parent_1
Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
- -> Seq Scan on nv_child_2010 nv_parent_1
+ -> Seq Scan on nv_child_2010 nv_parent_2
Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
- -> Seq Scan on nv_child_2011 nv_parent_2
+ -> Seq Scan on nv_child_2011 nv_parent_3
Filter: ((d >= '08-01-2011'::date) AND (d <= '08-31-2011'::date))
(7 rows)
QUERY PLAN
---------------------------------------------------------------------------
Append
- -> Seq Scan on nv_parent
+ -> Seq Scan on nv_parent nv_parent_1
Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
- -> Seq Scan on nv_child_2010 nv_parent_1
+ -> Seq Scan on nv_child_2010 nv_parent_2
Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
- -> Seq Scan on nv_child_2011 nv_parent_2
+ -> Seq Scan on nv_child_2011 nv_parent_3
Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
- -> Seq Scan on nv_child_2009 nv_parent_3
+ -> Seq Scan on nv_child_2009 nv_parent_4
Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
(9 rows)
QUERY PLAN
---------------------------------------------------------------------------
Append
- -> Seq Scan on nv_parent
+ -> Seq Scan on nv_parent nv_parent_1
Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
- -> Seq Scan on nv_child_2010 nv_parent_1
+ -> Seq Scan on nv_child_2010 nv_parent_2
Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
- -> Seq Scan on nv_child_2009 nv_parent_2
+ -> Seq Scan on nv_child_2009 nv_parent_3
Filter: ((d >= '08-01-2009'::date) AND (d <= '08-31-2009'::date))
(7 rows)
-> Limit
-> Seq Scan on int4_tbl
-> Append
- -> Index Scan using patest0i on patest0
+ -> Index Scan using patest0i on patest0 patest0_1
Index Cond: (id = int4_tbl.f1)
- -> Index Scan using patest1i on patest1 patest0_1
+ -> Index Scan using patest1i on patest1 patest0_2
Index Cond: (id = int4_tbl.f1)
- -> Index Scan using patest2i on patest2 patest0_2
+ -> Index Scan using patest2i on patest2 patest0_3
Index Cond: (id = int4_tbl.f1)
(10 rows)
-> Limit
-> Seq Scan on int4_tbl
-> Append
- -> Index Scan using patest0i on patest0
+ -> Index Scan using patest0i on patest0 patest0_1
Index Cond: (id = int4_tbl.f1)
- -> Index Scan using patest1i on patest1 patest0_1
+ -> Index Scan using patest1i on patest1 patest0_2
Index Cond: (id = int4_tbl.f1)
- -> Seq Scan on patest2 patest0_2
+ -> Seq Scan on patest2 patest0_3
Filter: (int4_tbl.f1 = id)
(10 rows)
-> Result
Output: matest0.id, matest0.name, (1 - matest0.id)
-> Append
- -> Seq Scan on public.matest0
- Output: matest0.id, matest0.name
- -> Seq Scan on public.matest1 matest0_1
+ -> Seq Scan on public.matest0 matest0_1
Output: matest0_1.id, matest0_1.name
- -> Seq Scan on public.matest2 matest0_2
+ -> Seq Scan on public.matest1 matest0_2
Output: matest0_2.id, matest0_2.name
- -> Seq Scan on public.matest3 matest0_3
+ -> Seq Scan on public.matest2 matest0_3
Output: matest0_3.id, matest0_3.name
+ -> Seq Scan on public.matest3 matest0_4
+ Output: matest0_4.id, matest0_4.name
(14 rows)
select * from matest0 order by 1-id;
Aggregate
Output: min((1 - matest0.id))
-> Append
- -> Seq Scan on public.matest0
- Output: matest0.id
- -> Seq Scan on public.matest1 matest0_1
+ -> Seq Scan on public.matest0 matest0_1
Output: matest0_1.id
- -> Seq Scan on public.matest2 matest0_2
+ -> Seq Scan on public.matest1 matest0_2
Output: matest0_2.id
- -> Seq Scan on public.matest3 matest0_3
+ -> Seq Scan on public.matest2 matest0_3
Output: matest0_3.id
+ -> Seq Scan on public.matest3 matest0_4
+ Output: matest0_4.id
(11 rows)
select min(1-id) from matest0;
------------------------------------------------------------------------
Merge Append
Sort Key: ((1 - matest0.id))
- -> Index Scan using matest0i on public.matest0
- Output: matest0.id, matest0.name, (1 - matest0.id)
- -> Index Scan using matest1i on public.matest1 matest0_1
+ -> Index Scan using matest0i on public.matest0 matest0_1
Output: matest0_1.id, matest0_1.name, (1 - matest0_1.id)
+ -> Index Scan using matest1i on public.matest1 matest0_2
+ Output: matest0_2.id, matest0_2.name, (1 - matest0_2.id)
-> Sort
- Output: matest0_2.id, matest0_2.name, ((1 - matest0_2.id))
- Sort Key: ((1 - matest0_2.id))
- -> Seq Scan on public.matest2 matest0_2
- Output: matest0_2.id, matest0_2.name, (1 - matest0_2.id)
- -> Index Scan using matest3i on public.matest3 matest0_3
- Output: matest0_3.id, matest0_3.name, (1 - matest0_3.id)
+ Output: matest0_3.id, matest0_3.name, ((1 - matest0_3.id))
+ Sort Key: ((1 - matest0_3.id))
+ -> Seq Scan on public.matest2 matest0_3
+ Output: matest0_3.id, matest0_3.name, (1 - matest0_3.id)
+ -> Index Scan using matest3i on public.matest3 matest0_4
+ Output: matest0_4.id, matest0_4.name, (1 - matest0_4.id)
(13 rows)
select * from matest0 order by 1-id;
Output: ((1 - matest0.id))
-> Merge Append
Sort Key: ((1 - matest0.id))
- -> Index Scan using matest0i on public.matest0
- Output: matest0.id, (1 - matest0.id)
- Index Cond: ((1 - matest0.id) IS NOT NULL)
- -> Index Scan using matest1i on public.matest1 matest0_1
+ -> Index Scan using matest0i on public.matest0 matest0_1
Output: matest0_1.id, (1 - matest0_1.id)
Index Cond: ((1 - matest0_1.id) IS NOT NULL)
+ -> Index Scan using matest1i on public.matest1 matest0_2
+ Output: matest0_2.id, (1 - matest0_2.id)
+ Index Cond: ((1 - matest0_2.id) IS NOT NULL)
-> Sort
- Output: matest0_2.id, ((1 - matest0_2.id))
- Sort Key: ((1 - matest0_2.id))
- -> Bitmap Heap Scan on public.matest2 matest0_2
- Output: matest0_2.id, (1 - matest0_2.id)
- Filter: ((1 - matest0_2.id) IS NOT NULL)
+ Output: matest0_3.id, ((1 - matest0_3.id))
+ Sort Key: ((1 - matest0_3.id))
+ -> Bitmap Heap Scan on public.matest2 matest0_3
+ Output: matest0_3.id, (1 - matest0_3.id)
+ Filter: ((1 - matest0_3.id) IS NOT NULL)
-> Bitmap Index Scan on matest2_pkey
- -> Index Scan using matest3i on public.matest3 matest0_3
- Output: matest0_3.id, (1 - matest0_3.id)
- Index Cond: ((1 - matest0_3.id) IS NOT NULL)
+ -> Index Scan using matest3i on public.matest3 matest0_4
+ Output: matest0_4.id, (1 - matest0_4.id)
+ Index Cond: ((1 - matest0_4.id) IS NOT NULL)
(25 rows)
select min(1-id) from matest0;
Merge Cond: (t1.b = t2.b)
-> Merge Append
Sort Key: t1.b
- -> Index Scan using matest0i on matest0 t1
- -> Index Scan using matest1i on matest1 t1_1
+ -> Index Scan using matest0i on matest0 t1_1
+ -> Index Scan using matest1i on matest1 t1_2
-> Materialize
-> Merge Append
Sort Key: t2.b
- -> Index Scan using matest0i on matest0 t2
+ -> Index Scan using matest0i on matest0 t2_1
Filter: (c = d)
- -> Index Scan using matest1i on matest1 t2_1
+ -> Index Scan using matest1i on matest1 t2_2
Filter: (c = d)
(14 rows)
QUERY PLAN
----------------------------------------------
Append
- -> Seq Scan on part_ab_cd list_parted
- -> Seq Scan on part_ef_gh list_parted_1
- -> Seq Scan on part_null_xy list_parted_2
+ -> Seq Scan on part_ab_cd list_parted_1
+ -> Seq Scan on part_ef_gh list_parted_2
+ -> Seq Scan on part_null_xy list_parted_3
(4 rows)
explain (costs off) select * from list_parted where a is null;
QUERY PLAN
----------------------------------------------
Append
- -> Seq Scan on part_ab_cd list_parted
+ -> Seq Scan on part_ab_cd list_parted_1
Filter: (a IS NOT NULL)
- -> Seq Scan on part_ef_gh list_parted_1
+ -> Seq Scan on part_ef_gh list_parted_2
Filter: (a IS NOT NULL)
- -> Seq Scan on part_null_xy list_parted_2
+ -> Seq Scan on part_null_xy list_parted_3
Filter: (a IS NOT NULL)
(7 rows)
QUERY PLAN
----------------------------------------------------------
Append
- -> Seq Scan on part_ab_cd list_parted
+ -> Seq Scan on part_ab_cd list_parted_1
Filter: ((a)::text = ANY ('{ab,cd,ef}'::text[]))
- -> Seq Scan on part_ef_gh list_parted_1
+ -> Seq Scan on part_ef_gh list_parted_2
Filter: ((a)::text = ANY ('{ab,cd,ef}'::text[]))
(5 rows)
QUERY PLAN
--------------------------------------------------------
Append
- -> Seq Scan on part_1_10_ab range_list_parted
- -> Seq Scan on part_1_10_cd range_list_parted_1
- -> Seq Scan on part_10_20_ab range_list_parted_2
- -> Seq Scan on part_10_20_cd range_list_parted_3
- -> Seq Scan on part_21_30_ab range_list_parted_4
- -> Seq Scan on part_21_30_cd range_list_parted_5
- -> Seq Scan on part_40_inf_ab range_list_parted_6
- -> Seq Scan on part_40_inf_cd range_list_parted_7
- -> Seq Scan on part_40_inf_null range_list_parted_8
+ -> Seq Scan on part_1_10_ab range_list_parted_1
+ -> Seq Scan on part_1_10_cd range_list_parted_2
+ -> Seq Scan on part_10_20_ab range_list_parted_3
+ -> Seq Scan on part_10_20_cd range_list_parted_4
+ -> Seq Scan on part_21_30_ab range_list_parted_5
+ -> Seq Scan on part_21_30_cd range_list_parted_6
+ -> Seq Scan on part_40_inf_ab range_list_parted_7
+ -> Seq Scan on part_40_inf_cd range_list_parted_8
+ -> Seq Scan on part_40_inf_null range_list_parted_9
(10 rows)
explain (costs off) select * from range_list_parted where a = 5;
QUERY PLAN
----------------------------------------------------
Append
- -> Seq Scan on part_1_10_ab range_list_parted
+ -> Seq Scan on part_1_10_ab range_list_parted_1
Filter: (a = 5)
- -> Seq Scan on part_1_10_cd range_list_parted_1
+ -> Seq Scan on part_1_10_cd range_list_parted_2
Filter: (a = 5)
(5 rows)
QUERY PLAN
------------------------------------------------------
Append
- -> Seq Scan on part_1_10_ab range_list_parted
+ -> Seq Scan on part_1_10_ab range_list_parted_1
Filter: (b = 'ab'::bpchar)
- -> Seq Scan on part_10_20_ab range_list_parted_1
+ -> Seq Scan on part_10_20_ab range_list_parted_2
Filter: (b = 'ab'::bpchar)
- -> Seq Scan on part_21_30_ab range_list_parted_2
+ -> Seq Scan on part_21_30_ab range_list_parted_3
Filter: (b = 'ab'::bpchar)
- -> Seq Scan on part_40_inf_ab range_list_parted_3
+ -> Seq Scan on part_40_inf_ab range_list_parted_4
Filter: (b = 'ab'::bpchar)
(9 rows)
QUERY PLAN
-----------------------------------------------------------------
Append
- -> Seq Scan on part_1_10_ab range_list_parted
+ -> Seq Scan on part_1_10_ab range_list_parted_1
Filter: ((a >= 3) AND (a <= 23) AND (b = 'ab'::bpchar))
- -> Seq Scan on part_10_20_ab range_list_parted_1
+ -> Seq Scan on part_10_20_ab range_list_parted_2
Filter: ((a >= 3) AND (a <= 23) AND (b = 'ab'::bpchar))
- -> Seq Scan on part_21_30_ab range_list_parted_2
+ -> Seq Scan on part_21_30_ab range_list_parted_3
Filter: ((a >= 3) AND (a <= 23) AND (b = 'ab'::bpchar))
(7 rows)
QUERY PLAN
--------------------------------------------------------
Append
- -> Seq Scan on part_1_10_ab range_list_parted
+ -> Seq Scan on part_1_10_ab range_list_parted_1
Filter: ((a IS NOT NULL) AND (a < 67))
- -> Seq Scan on part_1_10_cd range_list_parted_1
+ -> Seq Scan on part_1_10_cd range_list_parted_2
Filter: ((a IS NOT NULL) AND (a < 67))
- -> Seq Scan on part_10_20_ab range_list_parted_2
+ -> Seq Scan on part_10_20_ab range_list_parted_3
Filter: ((a IS NOT NULL) AND (a < 67))
- -> Seq Scan on part_10_20_cd range_list_parted_3
+ -> Seq Scan on part_10_20_cd range_list_parted_4
Filter: ((a IS NOT NULL) AND (a < 67))
- -> Seq Scan on part_21_30_ab range_list_parted_4
+ -> Seq Scan on part_21_30_ab range_list_parted_5
Filter: ((a IS NOT NULL) AND (a < 67))
- -> Seq Scan on part_21_30_cd range_list_parted_5
+ -> Seq Scan on part_21_30_cd range_list_parted_6
Filter: ((a IS NOT NULL) AND (a < 67))
- -> Seq Scan on part_40_inf_ab range_list_parted_6
+ -> Seq Scan on part_40_inf_ab range_list_parted_7
Filter: ((a IS NOT NULL) AND (a < 67))
- -> Seq Scan on part_40_inf_cd range_list_parted_7
+ -> Seq Scan on part_40_inf_cd range_list_parted_8
Filter: ((a IS NOT NULL) AND (a < 67))
- -> Seq Scan on part_40_inf_null range_list_parted_8
+ -> Seq Scan on part_40_inf_null range_list_parted_9
Filter: ((a IS NOT NULL) AND (a < 67))
(19 rows)
QUERY PLAN
--------------------------------------------------------
Append
- -> Seq Scan on part_40_inf_ab range_list_parted
+ -> Seq Scan on part_40_inf_ab range_list_parted_1
Filter: (a >= 30)
- -> Seq Scan on part_40_inf_cd range_list_parted_1
+ -> Seq Scan on part_40_inf_cd range_list_parted_2
Filter: (a >= 30)
- -> Seq Scan on part_40_inf_null range_list_parted_2
+ -> Seq Scan on part_40_inf_null range_list_parted_3
Filter: (a >= 30)
(7 rows)
QUERY PLAN
---------------------------------------------
Append
- -> Seq Scan on mcrparted0 mcrparted
+ -> Seq Scan on mcrparted0 mcrparted_1
Filter: (a = 0)
- -> Seq Scan on mcrparted_def mcrparted_1
+ -> Seq Scan on mcrparted_def mcrparted_2
Filter: (a = 0)
(5 rows)
QUERY PLAN
---------------------------------------------
Append
- -> Seq Scan on mcrparted1 mcrparted
+ -> Seq Scan on mcrparted1 mcrparted_1
Filter: ((a = 10) AND (abs(b) < 5))
- -> Seq Scan on mcrparted_def mcrparted_1
+ -> Seq Scan on mcrparted_def mcrparted_2
Filter: ((a = 10) AND (abs(b) < 5))
(5 rows)
QUERY PLAN
---------------------------------------------
Append
- -> Seq Scan on mcrparted1 mcrparted
+ -> Seq Scan on mcrparted1 mcrparted_1
Filter: ((a = 10) AND (abs(b) = 5))
- -> Seq Scan on mcrparted2 mcrparted_1
+ -> Seq Scan on mcrparted2 mcrparted_2
Filter: ((a = 10) AND (abs(b) = 5))
- -> Seq Scan on mcrparted_def mcrparted_2
+ -> Seq Scan on mcrparted_def mcrparted_3
Filter: ((a = 10) AND (abs(b) = 5))
(7 rows)
QUERY PLAN
---------------------------------------------
Append
- -> Seq Scan on mcrparted0 mcrparted
+ -> Seq Scan on mcrparted0 mcrparted_1
Filter: (abs(b) = 5)
- -> Seq Scan on mcrparted1 mcrparted_1
+ -> Seq Scan on mcrparted1 mcrparted_2
Filter: (abs(b) = 5)
- -> Seq Scan on mcrparted2 mcrparted_2
+ -> Seq Scan on mcrparted2 mcrparted_3
Filter: (abs(b) = 5)
- -> Seq Scan on mcrparted3 mcrparted_3
+ -> Seq Scan on mcrparted3 mcrparted_4
Filter: (abs(b) = 5)
- -> Seq Scan on mcrparted4 mcrparted_4
+ -> Seq Scan on mcrparted4 mcrparted_5
Filter: (abs(b) = 5)
- -> Seq Scan on mcrparted5 mcrparted_5
+ -> Seq Scan on mcrparted5 mcrparted_6
Filter: (abs(b) = 5)
- -> Seq Scan on mcrparted_def mcrparted_6
+ -> Seq Scan on mcrparted_def mcrparted_7
Filter: (abs(b) = 5)
(15 rows)
QUERY PLAN
---------------------------------------------
Append
- -> Seq Scan on mcrparted0 mcrparted
+ -> Seq Scan on mcrparted0 mcrparted_1
Filter: (a > '-1'::integer)
- -> Seq Scan on mcrparted1 mcrparted_1
+ -> Seq Scan on mcrparted1 mcrparted_2
Filter: (a > '-1'::integer)
- -> Seq Scan on mcrparted2 mcrparted_2
+ -> Seq Scan on mcrparted2 mcrparted_3
Filter: (a > '-1'::integer)
- -> Seq Scan on mcrparted3 mcrparted_3
+ -> Seq Scan on mcrparted3 mcrparted_4
Filter: (a > '-1'::integer)
- -> Seq Scan on mcrparted4 mcrparted_4
+ -> Seq Scan on mcrparted4 mcrparted_5
Filter: (a > '-1'::integer)
- -> Seq Scan on mcrparted5 mcrparted_5
+ -> Seq Scan on mcrparted5 mcrparted_6
Filter: (a > '-1'::integer)
- -> Seq Scan on mcrparted_def mcrparted_6
+ -> Seq Scan on mcrparted_def mcrparted_7
Filter: (a > '-1'::integer)
(15 rows)
QUERY PLAN
---------------------------------------------
Append
- -> Seq Scan on mcrparted3 mcrparted
+ -> Seq Scan on mcrparted3 mcrparted_1
Filter: ((c > 20) AND (a = 20))
- -> Seq Scan on mcrparted4 mcrparted_1
+ -> Seq Scan on mcrparted4 mcrparted_2
Filter: ((c > 20) AND (a = 20))
- -> Seq Scan on mcrparted5 mcrparted_2
+ -> Seq Scan on mcrparted5 mcrparted_3
Filter: ((c > 20) AND (a = 20))
- -> Seq Scan on mcrparted_def mcrparted_3
+ -> Seq Scan on mcrparted_def mcrparted_4
Filter: ((c > 20) AND (a = 20))
(9 rows)
-------------------------------------------------------------------------------
Merge Append
Sort Key: mcrparted.a, (abs(mcrparted.b)), mcrparted.c
- -> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted
- -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_1
- -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_2
- -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_3
- -> Index Scan using mcrparted4_a_abs_c_idx on mcrparted4 mcrparted_4
- -> Index Scan using mcrparted5_a_abs_c_idx on mcrparted5 mcrparted_5
- -> Index Scan using mcrparted_def_a_abs_c_idx on mcrparted_def mcrparted_6
+ -> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted_1
+ -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_2
+ -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_3
+ -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_4
+ -> Index Scan using mcrparted4_a_abs_c_idx on mcrparted4 mcrparted_5
+ -> Index Scan using mcrparted5_a_abs_c_idx on mcrparted5 mcrparted_6
+ -> Index Scan using mcrparted_def_a_abs_c_idx on mcrparted_def mcrparted_7
(9 rows)
drop table mcrparted_def;
QUERY PLAN
-------------------------------------------------------------------------
Append
- -> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted
- -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_1
- -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_2
- -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_3
- -> Index Scan using mcrparted4_a_abs_c_idx on mcrparted4 mcrparted_4
- -> Index Scan using mcrparted5_a_abs_c_idx on mcrparted5 mcrparted_5
+ -> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted_1
+ -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_2
+ -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_3
+ -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_4
+ -> Index Scan using mcrparted4_a_abs_c_idx on mcrparted4 mcrparted_5
+ -> Index Scan using mcrparted5_a_abs_c_idx on mcrparted5 mcrparted_6
(7 rows)
-- Append is used with subpaths in reverse order with backwards index scans
QUERY PLAN
----------------------------------------------------------------------------------
Append
- -> Index Scan Backward using mcrparted5_a_abs_c_idx on mcrparted5 mcrparted_5
- -> Index Scan Backward using mcrparted4_a_abs_c_idx on mcrparted4 mcrparted_4
- -> Index Scan Backward using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_3
- -> Index Scan Backward using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_2
- -> Index Scan Backward using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_1
- -> Index Scan Backward using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted
+ -> Index Scan Backward using mcrparted5_a_abs_c_idx on mcrparted5 mcrparted_6
+ -> Index Scan Backward using mcrparted4_a_abs_c_idx on mcrparted4 mcrparted_5
+ -> Index Scan Backward using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_4
+ -> Index Scan Backward using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_3
+ -> Index Scan Backward using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_2
+ -> Index Scan Backward using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted_1
(7 rows)
-- check that Append plan is used containing a MergeAppend for sub-partitions
QUERY PLAN
---------------------------------------------------------------------------------------
Append
- -> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted
- -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_1
- -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_2
- -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_3
- -> Index Scan using mcrparted4_a_abs_c_idx on mcrparted4 mcrparted_4
+ -> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted_1
+ -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_2
+ -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_3
+ -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_4
+ -> Index Scan using mcrparted4_a_abs_c_idx on mcrparted4 mcrparted_5
-> Merge Append
- Sort Key: mcrparted_5.a, (abs(mcrparted_5.b)), mcrparted_5.c
- -> Index Scan using mcrparted5a_a_abs_c_idx on mcrparted5a mcrparted_5
- -> Index Scan using mcrparted5_def_a_abs_c_idx on mcrparted5_def mcrparted_6
+ Sort Key: mcrparted_7.a, (abs(mcrparted_7.b)), mcrparted_7.c
+ -> Index Scan using mcrparted5a_a_abs_c_idx on mcrparted5a mcrparted_7
+ -> Index Scan using mcrparted5_def_a_abs_c_idx on mcrparted5_def mcrparted_8
(10 rows)
drop table mcrparted5_def;
QUERY PLAN
---------------------------------------------------------------------------
Append
- -> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted
- -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_1
- -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_2
- -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_3
- -> Index Scan using mcrparted4_a_abs_c_idx on mcrparted4 mcrparted_4
- -> Index Scan using mcrparted5a_a_abs_c_idx on mcrparted5a mcrparted_5
+ -> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted_1
+ -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_2
+ -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_3
+ -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_4
+ -> Index Scan using mcrparted4_a_abs_c_idx on mcrparted4 mcrparted_5
+ -> Index Scan using mcrparted5a_a_abs_c_idx on mcrparted5a mcrparted_6
(7 rows)
-- check that Append is used when the sub-partitioned tables are pruned
QUERY PLAN
-------------------------------------------------------------------------
Append
- -> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted
+ -> Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted_1
Index Cond: (a < 20)
- -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_1
+ -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_2
Index Cond: (a < 20)
- -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_2
+ -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_3
Index Cond: (a < 20)
- -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_3
+ -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_4
Index Cond: (a < 20)
(9 rows)
QUERY PLAN
------------------------------------------------------------------------
Append
- -> Index Only Scan using mclparted1_a_idx on mclparted1 mclparted
- -> Index Only Scan using mclparted2_a_idx on mclparted2 mclparted_1
+ -> Index Only Scan using mclparted1_a_idx on mclparted1 mclparted_1
+ -> Index Only Scan using mclparted2_a_idx on mclparted2 mclparted_2
(3 rows)
-- Ensure a MergeAppend is used when a partition exists with interleaved
----------------------------------------------------------------------------
Merge Append
Sort Key: mclparted.a
- -> Index Only Scan using mclparted1_a_idx on mclparted1 mclparted
- -> Index Only Scan using mclparted2_a_idx on mclparted2 mclparted_1
- -> Index Only Scan using mclparted3_5_a_idx on mclparted3_5 mclparted_2
- -> Index Only Scan using mclparted4_a_idx on mclparted4 mclparted_3
+ -> Index Only Scan using mclparted1_a_idx on mclparted1 mclparted_1
+ -> Index Only Scan using mclparted2_a_idx on mclparted2 mclparted_2
+ -> Index Only Scan using mclparted3_5_a_idx on mclparted3_5 mclparted_3
+ -> Index Only Scan using mclparted4_a_idx on mclparted4 mclparted_4
(6 rows)
drop table mclparted;
Limit
-> Append
-> Sort
- Sort Key: mcrparted.a, (abs(mcrparted.b)), mcrparted.c
- -> Seq Scan on mcrparted0 mcrparted
+ Sort Key: mcrparted_1.a, (abs(mcrparted_1.b)), mcrparted_1.c
+ -> Seq Scan on mcrparted0 mcrparted_1
Filter: (a < 20)
- -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_1
+ -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_2
Index Cond: (a < 20)
- -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_2
+ -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_3
Index Cond: (a < 20)
- -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_3
+ -> Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_4
Index Cond: (a < 20)
(12 rows)
QUERY PLAN
-------------------------------------------------------------------------
Append
- -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted
+ -> Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_1
Index Cond: (a = 10)
- -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_1
+ -> Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_2
Index Cond: (a = 10)
(5 rows)
create table bool_lp_false partition of bool_lp for values in(false);
create index on bool_lp (b);
explain (costs off) select * from bool_lp order by b;
- QUERY PLAN
---------------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------
Append
- -> Index Only Scan using bool_lp_false_b_idx on bool_lp_false bool_lp
- -> Index Only Scan using bool_lp_true_b_idx on bool_lp_true bool_lp_1
+ -> Index Only Scan using bool_lp_false_b_idx on bool_lp_false bool_lp_1
+ -> Index Only Scan using bool_lp_true_b_idx on bool_lp_true bool_lp_2
(3 rows)
drop table bool_lp;
QUERY PLAN
----------------------------------------------------------------------------------
Append
- -> Index Only Scan using bool_rp_true_1k_b_a_idx on bool_rp_true_1k bool_rp
+ -> Index Only Scan using bool_rp_true_1k_b_a_idx on bool_rp_true_1k bool_rp_1
Index Cond: (b = true)
- -> Index Only Scan using bool_rp_true_2k_b_a_idx on bool_rp_true_2k bool_rp_1
+ -> Index Only Scan using bool_rp_true_2k_b_a_idx on bool_rp_true_2k bool_rp_2
Index Cond: (b = true)
(5 rows)
QUERY PLAN
------------------------------------------------------------------------------------
Append
- -> Index Only Scan using bool_rp_false_1k_b_a_idx on bool_rp_false_1k bool_rp
+ -> Index Only Scan using bool_rp_false_1k_b_a_idx on bool_rp_false_1k bool_rp_1
Index Cond: (b = false)
- -> Index Only Scan using bool_rp_false_2k_b_a_idx on bool_rp_false_2k bool_rp_1
+ -> Index Only Scan using bool_rp_false_2k_b_a_idx on bool_rp_false_2k bool_rp_2
Index Cond: (b = false)
(5 rows)
QUERY PLAN
----------------------------------------------------------------------------------
Append
- -> Index Only Scan using bool_rp_true_1k_b_a_idx on bool_rp_true_1k bool_rp
+ -> Index Only Scan using bool_rp_true_1k_b_a_idx on bool_rp_true_1k bool_rp_1
Index Cond: (b = true)
- -> Index Only Scan using bool_rp_true_2k_b_a_idx on bool_rp_true_2k bool_rp_1
+ -> Index Only Scan using bool_rp_true_2k_b_a_idx on bool_rp_true_2k bool_rp_2
Index Cond: (b = true)
(5 rows)
QUERY PLAN
------------------------------------------------------------------------------------
Append
- -> Index Only Scan using bool_rp_false_1k_b_a_idx on bool_rp_false_1k bool_rp
+ -> Index Only Scan using bool_rp_false_1k_b_a_idx on bool_rp_false_1k bool_rp_1
Index Cond: (b = false)
- -> Index Only Scan using bool_rp_false_2k_b_a_idx on bool_rp_false_2k bool_rp_1
+ -> Index Only Scan using bool_rp_false_2k_b_a_idx on bool_rp_false_2k bool_rp_2
Index Cond: (b = false)
(5 rows)
QUERY PLAN
-------------------------------------------------------------------------------------
Append
- -> Index Only Scan using range_parted1_a_b_c_idx on range_parted1 range_parted
- -> Index Only Scan using range_parted2_a_b_c_idx on range_parted2 range_parted_1
+ -> Index Only Scan using range_parted1_a_b_c_idx on range_parted1 range_parted_1
+ -> Index Only Scan using range_parted2_a_b_c_idx on range_parted2 range_parted_2
(3 rows)
explain (costs off) select * from range_parted order by a desc,b desc,c desc;
QUERY PLAN
----------------------------------------------------------------------------------------------
Append
- -> Index Only Scan Backward using range_parted2_a_b_c_idx on range_parted2 range_parted_1
- -> Index Only Scan Backward using range_parted1_a_b_c_idx on range_parted1 range_parted
+ -> Index Only Scan Backward using range_parted2_a_b_c_idx on range_parted2 range_parted_2
+ -> Index Only Scan Backward using range_parted1_a_b_c_idx on range_parted1 range_parted_1
(3 rows)
drop table range_parted;
(select t2.a as t2a, t3.a t3a, least(t1.a, t2.a, t3.a) phv
from join_pt1 t2 join join_ut1 t3 on t2.a = t3.b) ss
on t1.a = ss.t2a order by t1.a;
- QUERY PLAN
-------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------------
Sort
Output: t1.b, (LEAST(t1.a, t2.a, t3.a)), t1.a
Sort Key: t1.a
-> Hash
Output: t2.a
-> Append
- -> Seq Scan on public.join_pt1p1p1 t2
- Output: t2.a
- Filter: (t1.a = t2.a)
- -> Seq Scan on public.join_pt1p2 t2_1
+ -> Seq Scan on public.join_pt1p1p1 t2_1
Output: t2_1.a
Filter: (t1.a = t2_1.a)
+ -> Seq Scan on public.join_pt1p2 t2_2
+ Output: t2_2.a
+ Filter: (t1.a = t2_2.a)
(21 rows)
select t1.b, ss.phv from join_ut1 t1 left join lateral
Hash Key: pagg_tab.c
Group Key: ()
-> Append
- -> Seq Scan on pagg_tab_p1 pagg_tab
- -> Seq Scan on pagg_tab_p2 pagg_tab_1
- -> Seq Scan on pagg_tab_p3 pagg_tab_2
+ -> Seq Scan on pagg_tab_p1 pagg_tab_1
+ -> Seq Scan on pagg_tab_p2 pagg_tab_2
+ -> Seq Scan on pagg_tab_p3 pagg_tab_3
(9 rows)
-- ORDERED SET within the aggregate.
-> Sort
Sort Key: pagg_tab.a
-> Append
- -> Seq Scan on pagg_tab_p1 pagg_tab
- -> Seq Scan on pagg_tab_p2 pagg_tab_1
- -> Seq Scan on pagg_tab_p3 pagg_tab_2
+ -> Seq Scan on pagg_tab_p1 pagg_tab_1
+ -> Seq Scan on pagg_tab_p2 pagg_tab_2
+ -> Seq Scan on pagg_tab_p3 pagg_tab_3
(10 rows)
-- JOIN query
-> Hash Join
Hash Cond: (t1.x = t2.y)
-> Append
- -> Seq Scan on pagg_tab1_p1 t1
- -> Seq Scan on pagg_tab1_p2 t1_1
- -> Seq Scan on pagg_tab1_p3 t1_2
+ -> Seq Scan on pagg_tab1_p1 t1_1
+ -> Seq Scan on pagg_tab1_p2 t1_2
+ -> Seq Scan on pagg_tab1_p3 t1_3
-> Hash
-> Append
- -> Seq Scan on pagg_tab2_p1 t2
- -> Seq Scan on pagg_tab2_p2 t2_1
- -> Seq Scan on pagg_tab2_p3 t2_2
+ -> Seq Scan on pagg_tab2_p1 t2_1
+ -> Seq Scan on pagg_tab2_p2 t2_2
+ -> Seq Scan on pagg_tab2_p3 t2_3
(15 rows)
SELECT t1.x, sum(t1.y), count(t1) FROM pagg_tab1 t1, pagg_tab2 t2 WHERE t1.x = t2.y GROUP BY t1.x ORDER BY 1, 2, 3;
Hash Cond: (pagg_tab1.x = pagg_tab2.y)
Filter: ((pagg_tab1.x > 5) OR (pagg_tab2.y < 20))
-> Append
- -> Seq Scan on pagg_tab1_p1 pagg_tab1
+ -> Seq Scan on pagg_tab1_p1 pagg_tab1_1
Filter: (x < 20)
- -> Seq Scan on pagg_tab1_p2 pagg_tab1_1
+ -> Seq Scan on pagg_tab1_p2 pagg_tab1_2
Filter: (x < 20)
-> Hash
-> Append
- -> Seq Scan on pagg_tab2_p2 pagg_tab2
+ -> Seq Scan on pagg_tab2_p2 pagg_tab2_1
Filter: (y > 10)
- -> Seq Scan on pagg_tab2_p3 pagg_tab2_1
+ -> Seq Scan on pagg_tab2_p3 pagg_tab2_2
Filter: (y > 10)
(18 rows)
Hash Cond: (pagg_tab1.x = pagg_tab2.y)
Filter: ((pagg_tab1.x > 5) OR (pagg_tab2.y < 20))
-> Append
- -> Seq Scan on pagg_tab1_p1 pagg_tab1
+ -> Seq Scan on pagg_tab1_p1 pagg_tab1_1
Filter: (x < 20)
- -> Seq Scan on pagg_tab1_p2 pagg_tab1_1
+ -> Seq Scan on pagg_tab1_p2 pagg_tab1_2
Filter: (x < 20)
-> Hash
-> Append
- -> Seq Scan on pagg_tab2_p2 pagg_tab2
+ -> Seq Scan on pagg_tab2_p2 pagg_tab2_1
Filter: (y > 10)
- -> Seq Scan on pagg_tab2_p3 pagg_tab2_1
+ -> Seq Scan on pagg_tab2_p3 pagg_tab2_2
Filter: (y > 10)
(18 rows)
QUERY PLAN
--------------------------------------------------------------------------------------------
Sort
- Sort Key: pagg_tab_ml_1.a, (sum(pagg_tab_ml_1.b)), (array_agg(DISTINCT pagg_tab_ml_1.c))
+ Sort Key: pagg_tab_ml_2.a, (sum(pagg_tab_ml_2.b)), (array_agg(DISTINCT pagg_tab_ml_2.c))
-> Gather
Workers Planned: 2
-> Parallel Append
-> GroupAggregate
- Group Key: pagg_tab_ml_1.a
- Filter: (avg(pagg_tab_ml_1.b) < '3'::numeric)
+ Group Key: pagg_tab_ml_2.a
+ Filter: (avg(pagg_tab_ml_2.b) < '3'::numeric)
-> Sort
- Sort Key: pagg_tab_ml_1.a
+ Sort Key: pagg_tab_ml_2.a
-> Append
- -> Seq Scan on pagg_tab_ml_p2_s1 pagg_tab_ml_1
- -> Seq Scan on pagg_tab_ml_p2_s2 pagg_tab_ml_2
+ -> Seq Scan on pagg_tab_ml_p2_s1 pagg_tab_ml_2
+ -> Seq Scan on pagg_tab_ml_p2_s2 pagg_tab_ml_3
-> GroupAggregate
- Group Key: pagg_tab_ml_3.a
- Filter: (avg(pagg_tab_ml_3.b) < '3'::numeric)
+ Group Key: pagg_tab_ml_5.a
+ Filter: (avg(pagg_tab_ml_5.b) < '3'::numeric)
-> Sort
- Sort Key: pagg_tab_ml_3.a
+ Sort Key: pagg_tab_ml_5.a
-> Append
- -> Seq Scan on pagg_tab_ml_p3_s1 pagg_tab_ml_3
- -> Seq Scan on pagg_tab_ml_p3_s2 pagg_tab_ml_4
+ -> Seq Scan on pagg_tab_ml_p3_s1 pagg_tab_ml_5
+ -> Seq Scan on pagg_tab_ml_p3_s2 pagg_tab_ml_6
-> GroupAggregate
Group Key: pagg_tab_ml.a
Filter: (avg(pagg_tab_ml.b) < '3'::numeric)
Workers Planned: 2
-> Parallel Append
-> GroupAggregate
- Group Key: pagg_tab_ml_1.a
- Filter: (avg(pagg_tab_ml_1.b) < '3'::numeric)
+ Group Key: pagg_tab_ml_2.a
+ Filter: (avg(pagg_tab_ml_2.b) < '3'::numeric)
-> Sort
- Sort Key: pagg_tab_ml_1.a
+ Sort Key: pagg_tab_ml_2.a
-> Append
- -> Seq Scan on pagg_tab_ml_p2_s1 pagg_tab_ml_1
- -> Seq Scan on pagg_tab_ml_p2_s2 pagg_tab_ml_2
+ -> Seq Scan on pagg_tab_ml_p2_s1 pagg_tab_ml_2
+ -> Seq Scan on pagg_tab_ml_p2_s2 pagg_tab_ml_3
-> GroupAggregate
- Group Key: pagg_tab_ml_3.a
- Filter: (avg(pagg_tab_ml_3.b) < '3'::numeric)
+ Group Key: pagg_tab_ml_5.a
+ Filter: (avg(pagg_tab_ml_5.b) < '3'::numeric)
-> Sort
- Sort Key: pagg_tab_ml_3.a
+ Sort Key: pagg_tab_ml_5.a
-> Append
- -> Seq Scan on pagg_tab_ml_p3_s1 pagg_tab_ml_3
- -> Seq Scan on pagg_tab_ml_p3_s2 pagg_tab_ml_4
+ -> Seq Scan on pagg_tab_ml_p3_s1 pagg_tab_ml_5
+ -> Seq Scan on pagg_tab_ml_p3_s2 pagg_tab_ml_6
-> GroupAggregate
Group Key: pagg_tab_ml.a
Filter: (avg(pagg_tab_ml.b) < '3'::numeric)
Filter: (avg(pagg_tab_ml.b) < '3'::numeric)
-> Seq Scan on pagg_tab_ml_p1 pagg_tab_ml
-> Finalize GroupAggregate
- Group Key: pagg_tab_ml_1.a
- Filter: (avg(pagg_tab_ml_1.b) < '3'::numeric)
+ Group Key: pagg_tab_ml_2.a
+ Filter: (avg(pagg_tab_ml_2.b) < '3'::numeric)
-> Sort
- Sort Key: pagg_tab_ml_1.a
+ Sort Key: pagg_tab_ml_2.a
-> Append
- -> Partial HashAggregate
- Group Key: pagg_tab_ml_1.a
- -> Seq Scan on pagg_tab_ml_p2_s1 pagg_tab_ml_1
-> Partial HashAggregate
Group Key: pagg_tab_ml_2.a
- -> Seq Scan on pagg_tab_ml_p2_s2 pagg_tab_ml_2
+ -> Seq Scan on pagg_tab_ml_p2_s1 pagg_tab_ml_2
+ -> Partial HashAggregate
+ Group Key: pagg_tab_ml_3.a
+ -> Seq Scan on pagg_tab_ml_p2_s2 pagg_tab_ml_3
-> Finalize GroupAggregate
- Group Key: pagg_tab_ml_3.a
- Filter: (avg(pagg_tab_ml_3.b) < '3'::numeric)
+ Group Key: pagg_tab_ml_5.a
+ Filter: (avg(pagg_tab_ml_5.b) < '3'::numeric)
-> Sort
- Sort Key: pagg_tab_ml_3.a
+ Sort Key: pagg_tab_ml_5.a
-> Append
-> Partial HashAggregate
- Group Key: pagg_tab_ml_3.a
- -> Seq Scan on pagg_tab_ml_p3_s1 pagg_tab_ml_3
+ Group Key: pagg_tab_ml_5.a
+ -> Seq Scan on pagg_tab_ml_p3_s1 pagg_tab_ml_5
-> Partial HashAggregate
- Group Key: pagg_tab_ml_4.a
- -> Seq Scan on pagg_tab_ml_p3_s2 pagg_tab_ml_4
+ Group Key: pagg_tab_ml_6.a
+ -> Seq Scan on pagg_tab_ml_p3_s2 pagg_tab_ml_6
(31 rows)
SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER BY 1, 2, 3;
Group Key: pagg_tab_ml.a
-> Parallel Seq Scan on pagg_tab_ml_p1 pagg_tab_ml
-> Finalize GroupAggregate
- Group Key: pagg_tab_ml_1.a
- Filter: (avg(pagg_tab_ml_1.b) < '3'::numeric)
+ Group Key: pagg_tab_ml_2.a
+ Filter: (avg(pagg_tab_ml_2.b) < '3'::numeric)
-> Gather Merge
Workers Planned: 2
-> Sort
- Sort Key: pagg_tab_ml_1.a
+ Sort Key: pagg_tab_ml_2.a
-> Parallel Append
- -> Partial HashAggregate
- Group Key: pagg_tab_ml_1.a
- -> Parallel Seq Scan on pagg_tab_ml_p2_s1 pagg_tab_ml_1
-> Partial HashAggregate
Group Key: pagg_tab_ml_2.a
- -> Parallel Seq Scan on pagg_tab_ml_p2_s2 pagg_tab_ml_2
+ -> Parallel Seq Scan on pagg_tab_ml_p2_s1 pagg_tab_ml_2
+ -> Partial HashAggregate
+ Group Key: pagg_tab_ml_3.a
+ -> Parallel Seq Scan on pagg_tab_ml_p2_s2 pagg_tab_ml_3
-> Finalize GroupAggregate
- Group Key: pagg_tab_ml_3.a
- Filter: (avg(pagg_tab_ml_3.b) < '3'::numeric)
+ Group Key: pagg_tab_ml_5.a
+ Filter: (avg(pagg_tab_ml_5.b) < '3'::numeric)
-> Gather Merge
Workers Planned: 2
-> Sort
- Sort Key: pagg_tab_ml_3.a
+ Sort Key: pagg_tab_ml_5.a
-> Parallel Append
-> Partial HashAggregate
- Group Key: pagg_tab_ml_3.a
- -> Parallel Seq Scan on pagg_tab_ml_p3_s1 pagg_tab_ml_3
+ Group Key: pagg_tab_ml_5.a
+ -> Parallel Seq Scan on pagg_tab_ml_p3_s1 pagg_tab_ml_5
-> Partial HashAggregate
- Group Key: pagg_tab_ml_4.a
- -> Parallel Seq Scan on pagg_tab_ml_p3_s2 pagg_tab_ml_4
+ Group Key: pagg_tab_ml_6.a
+ -> Parallel Seq Scan on pagg_tab_ml_p3_s2 pagg_tab_ml_6
(41 rows)
SELECT a, sum(b), count(*) FROM pagg_tab_ml GROUP BY a HAVING avg(b) < 3 ORDER BY 1, 2, 3;
-> Partial HashAggregate
Group Key: pagg_tab_para.x
-> Parallel Append
- -> Seq Scan on pagg_tab_para_p1 pagg_tab_para
- -> Seq Scan on pagg_tab_para_p3 pagg_tab_para_2
- -> Parallel Seq Scan on pagg_tab_para_p2 pagg_tab_para_1
+ -> Seq Scan on pagg_tab_para_p1 pagg_tab_para_1
+ -> Seq Scan on pagg_tab_para_p3 pagg_tab_para_3
+ -> Parallel Seq Scan on pagg_tab_para_p2 pagg_tab_para_2
(15 rows)
SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < 7 ORDER BY 1, 2, 3;
-> Partial HashAggregate
Group Key: pagg_tab_para.x
-> Parallel Append
- -> Seq Scan on pagg_tab_para_p1 pagg_tab_para
- -> Seq Scan on pagg_tab_para_p2 pagg_tab_para_1
- -> Seq Scan on pagg_tab_para_p3 pagg_tab_para_2
+ -> Seq Scan on pagg_tab_para_p1 pagg_tab_para_1
+ -> Seq Scan on pagg_tab_para_p2 pagg_tab_para_2
+ -> Seq Scan on pagg_tab_para_p3 pagg_tab_para_3
(15 rows)
SELECT x, sum(y), avg(y), count(*) FROM pagg_tab_para GROUP BY x HAVING avg(y) < 7 ORDER BY 1, 2, 3;
Sort Key: t1.a
-> Append
-> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Join
- Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Hash Join
- Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ Hash Cond: (t2_3.b = t1_3.a)
+ -> Seq Scan on prt2_p3 t2_3
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p3 t1_3
Filter: (b = 0)
(21 rows)
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p3 t1_3
Filter: (b = 0)
(16 rows)
Sort Key: t1.a, t2.b
-> Append
-> Hash Right Join
- Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
-> Hash Right Join
- Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-> Nested Loop Left Join
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t2_2.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
(20 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
Sort
Sort Key: prt1.a, prt2.b
-> Append
- -> Hash Full Join
- Hash Cond: (prt1.a = prt2.b)
- Filter: (((50) = prt1.a) OR ((75) = prt2.b))
- -> Seq Scan on prt1_p1 prt1
- Filter: (b = 0)
- -> Hash
- -> Seq Scan on prt2_p1 prt2
- Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_1.a = prt2_1.b)
Filter: (((50) = prt1_1.a) OR ((75) = prt2_1.b))
- -> Seq Scan on prt1_p2 prt1_1
+ -> Seq Scan on prt1_p1 prt1_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p2 prt2_1
+ -> Seq Scan on prt2_p1 prt2_1
Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_2.a = prt2_2.b)
Filter: (((50) = prt1_2.a) OR ((75) = prt2_2.b))
- -> Seq Scan on prt1_p3 prt1_2
+ -> Seq Scan on prt1_p2 prt1_2
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p3 prt2_2
+ -> Seq Scan on prt2_p2 prt2_2
+ Filter: (a = 0)
+ -> Hash Full Join
+ Hash Cond: (prt1_3.a = prt2_3.b)
+ Filter: (((50) = prt1_3.a) OR ((75) = prt2_3.b))
+ -> Seq Scan on prt1_p3 prt1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p3 prt2_3
Filter: (a = 0)
(27 rows)
-> Hash Right Join
Hash Cond: (prt2.b = prt1.a)
-> Append
- -> Seq Scan on prt2_p2 prt2
+ -> Seq Scan on prt2_p2 prt2_1
Filter: (b > 250)
- -> Seq Scan on prt2_p3 prt2_1
+ -> Seq Scan on prt2_p3 prt2_2
Filter: (b > 250)
-> Hash
-> Append
- -> Seq Scan on prt1_p1 prt1
+ -> Seq Scan on prt1_p1 prt1_1
Filter: ((a < 450) AND (b = 0))
- -> Seq Scan on prt1_p2 prt1_1
+ -> Seq Scan on prt1_p2 prt1_2
Filter: ((a < 450) AND (b = 0))
(15 rows)
Hash Cond: (prt1.a = prt2.b)
Filter: ((prt1.b = 0) OR (prt2.a = 0))
-> Append
- -> Seq Scan on prt1_p1 prt1
+ -> Seq Scan on prt1_p1 prt1_1
Filter: (a < 450)
- -> Seq Scan on prt1_p2 prt1_1
+ -> Seq Scan on prt1_p2 prt1_2
Filter: (a < 450)
-> Hash
-> Append
- -> Seq Scan on prt2_p2 prt2
+ -> Seq Scan on prt2_p2 prt2_1
Filter: (b > 250)
- -> Seq Scan on prt2_p3 prt2_1
+ -> Seq Scan on prt2_p3 prt2_2
Filter: (b > 250)
(16 rows)
Sort Key: t1.a
-> Append
-> Hash Semi Join
- Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
-> Hash Semi Join
- Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-> Nested Loop Semi Join
- Join Filter: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ Join Filter: (t1_3.a = t2_3.b)
+ -> Seq Scan on prt1_p3 t1_3
Filter: (b = 0)
-> Materialize
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
(24 rows)
--------------------------------------------------
Aggregate
-> Append
- -> Hash Anti Join
- Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
- -> Hash
- -> Seq Scan on prt2_p1 t2
-> Hash Anti Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash Anti Join
Hash Cond: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash Anti Join
+ Hash Cond: (t1_3.a = t2_3.b)
+ -> Seq Scan on prt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_3
(17 rows)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
Sort Key: t1.a
-> Append
-> Nested Loop Left Join
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p1_a on prt1_p1 t2
- Index Cond: (a = t1.a)
- -> Index Scan using iprt2_p1_b on prt2_p1 t3
- Index Cond: (b = t2.a)
- -> Nested Loop Left Join
- -> Seq Scan on prt1_p2 t1_1
- Filter: (b = 0)
- -> Nested Loop
- -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_1
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
Index Cond: (a = t1_1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t3_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t3_1
Index Cond: (b = t2_1.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_2
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
Index Cond: (a = t1_2.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t3_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t3_2
Index Cond: (b = t2_2.a)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.a)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t3_3
+ Index Cond: (b = t2_3.a)
(27 rows)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
Hash Cond: ((t1.c)::text = (t2.c)::text)
Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
-> Hash
-> Append
- -> Hash Join
- Hash Cond: (t2.a = t3.b)
- -> Seq Scan on prt1_p1 t2
- -> Hash
- -> Seq Scan on prt2_p1 t3
-> Hash Join
Hash Cond: (t2_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t2_1
+ -> Seq Scan on prt1_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p1 t3_1
-> Hash Join
Hash Cond: (t2_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t2_3.a = t3_3.b)
+ -> Seq Scan on prt1_p3 t2_3
-> Hash
- -> Seq Scan on prt2_p3 t3_2
+ -> Seq Scan on prt2_p3 t3_3
(26 rows)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
Sort Key: t1.a, t2.b
-> Append
-> Hash Join
- Hash Cond: (((t2.b + t2.a) / 2) = ((t1.a + t1.b) / 2))
- -> Seq Scan on prt2_e_p1 t2
+ Hash Cond: (((t2_1.b + t2_1.a) / 2) = ((t1_1.a + t1_1.b) / 2))
+ -> Seq Scan on prt2_e_p1 t2_1
-> Hash
- -> Seq Scan on prt1_e_p1 t1
+ -> Seq Scan on prt1_e_p1 t1_1
Filter: (c = 0)
-> Hash Join
- Hash Cond: (((t2_1.b + t2_1.a) / 2) = ((t1_1.a + t1_1.b) / 2))
- -> Seq Scan on prt2_e_p2 t2_1
+ Hash Cond: (((t2_2.b + t2_2.a) / 2) = ((t1_2.a + t1_2.b) / 2))
+ -> Seq Scan on prt2_e_p2 t2_2
-> Hash
- -> Seq Scan on prt1_e_p2 t1_1
+ -> Seq Scan on prt1_e_p2 t1_2
Filter: (c = 0)
-> Hash Join
- Hash Cond: (((t2_2.b + t2_2.a) / 2) = ((t1_2.a + t1_2.b) / 2))
- -> Seq Scan on prt2_e_p3 t2_2
+ Hash Cond: (((t2_3.b + t2_3.a) / 2) = ((t1_3.a + t1_3.b) / 2))
+ -> Seq Scan on prt2_e_p3 t2_3
-> Hash
- -> Seq Scan on prt1_e_p3 t1_2
+ -> Seq Scan on prt1_e_p3 t1_3
Filter: (c = 0)
(21 rows)
Sort
Sort Key: t1.a
-> Append
- -> Nested Loop
- Join Filter: (t1.a = ((t3.a + t3.b) / 2))
- -> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
- -> Hash
- -> Seq Scan on prt1_p1 t1
- Filter: (b = 0)
- -> Index Scan using iprt1_e_p1_ab2 on prt1_e_p1 t3
- Index Cond: (((a + b) / 2) = t2.b)
-> Nested Loop
Join Filter: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_1
+ -> Index Scan using iprt1_e_p1_ab2 on prt1_e_p1 t3_1
Index Cond: (((a + b) / 2) = t2_1.b)
-> Nested Loop
Join Filter: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_2
Index Cond: (((a + b) / 2) = t2_2.b)
+ -> Nested Loop
+ Join Filter: (t1_3.a = ((t3_3.a + t3_3.b) / 2))
+ -> Hash Join
+ Hash Cond: (t2_3.b = t1_3.a)
+ -> Seq Scan on prt2_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t2_3.b)
(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Hash Right Join
- Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
- -> Seq Scan on prt1_e_p1 t3
+ Hash Cond: (((t3_1.a + t3_1.b) / 2) = t1_1.a)
+ -> Seq Scan on prt1_e_p1 t3_1
-> Hash
-> Hash Right Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
- Hash Cond: (((t3_1.a + t3_1.b) / 2) = t1_1.a)
- -> Seq Scan on prt1_e_p2 t3_1
+ Hash Cond: (((t3_2.a + t3_2.b) / 2) = t1_2.a)
+ -> Seq Scan on prt1_e_p2 t3_2
-> Hash
-> Hash Right Join
- Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Hash Right Join
- Hash Cond: (((t3_2.a + t3_2.b) / 2) = t1_2.a)
- -> Seq Scan on prt1_e_p3 t3_2
+ Hash Cond: (((t3_3.a + t3_3.b) / 2) = t1_3.a)
+ -> Seq Scan on prt1_e_p3 t3_3
-> Hash
-> Hash Right Join
- Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ Hash Cond: (t2_3.b = t1_3.a)
+ -> Seq Scan on prt2_p3 t2_3
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p3 t1_3
Filter: (b = 0)
(33 rows)
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
- -> Nested Loop Left Join
- -> Hash Right Join
- Hash Cond: (t1.a = ((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_p1 t1
- -> Hash
- -> Seq Scan on prt1_e_p1 t3
- Filter: (c = 0)
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
- Index Cond: (b = t1.a)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t2_1
Index Cond: (b = t1_1.a)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t2_2
Index Cond: (b = t1_2.a)
+ -> Nested Loop Left Join
+ -> Hash Right Join
+ Hash Cond: (t1_3.a = ((t3_3.a + t3_3.b) / 2))
+ -> Seq Scan on prt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
(30 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
Sort Key: prt1.a, prt2.b, ((prt1_e.a + prt1_e.b))
-> Append
-> Hash Full Join
- Hash Cond: (prt1.a = ((prt1_e.a + prt1_e.b) / 2))
- Filter: ((prt1.a = (50)) OR (prt2.b = (75)) OR (((prt1_e.a + prt1_e.b) / 2) = (50)))
+ Hash Cond: (prt1_1.a = ((prt1_e_1.a + prt1_e_1.b) / 2))
+ Filter: ((prt1_1.a = (50)) OR (prt2_1.b = (75)) OR (((prt1_e_1.a + prt1_e_1.b) / 2) = (50)))
-> Hash Full Join
- Hash Cond: (prt1.a = prt2.b)
- -> Seq Scan on prt1_p1 prt1
+ Hash Cond: (prt1_1.a = prt2_1.b)
+ -> Seq Scan on prt1_p1 prt1_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1 prt2
+ -> Seq Scan on prt2_p1 prt2_1
Filter: (a = 0)
-> Hash
- -> Seq Scan on prt1_e_p1 prt1_e
+ -> Seq Scan on prt1_e_p1 prt1_e_1
Filter: (c = 0)
-> Hash Full Join
- Hash Cond: (prt1_1.a = ((prt1_e_1.a + prt1_e_1.b) / 2))
- Filter: ((prt1_1.a = (50)) OR (prt2_1.b = (75)) OR (((prt1_e_1.a + prt1_e_1.b) / 2) = (50)))
+ Hash Cond: (prt1_2.a = ((prt1_e_2.a + prt1_e_2.b) / 2))
+ Filter: ((prt1_2.a = (50)) OR (prt2_2.b = (75)) OR (((prt1_e_2.a + prt1_e_2.b) / 2) = (50)))
-> Hash Full Join
- Hash Cond: (prt1_1.a = prt2_1.b)
- -> Seq Scan on prt1_p2 prt1_1
+ Hash Cond: (prt1_2.a = prt2_2.b)
+ -> Seq Scan on prt1_p2 prt1_2
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p2 prt2_1
+ -> Seq Scan on prt2_p2 prt2_2
Filter: (a = 0)
-> Hash
- -> Seq Scan on prt1_e_p2 prt1_e_1
+ -> Seq Scan on prt1_e_p2 prt1_e_2
Filter: (c = 0)
-> Hash Full Join
- Hash Cond: (prt1_2.a = ((prt1_e_2.a + prt1_e_2.b) / 2))
- Filter: ((prt1_2.a = (50)) OR (prt2_2.b = (75)) OR (((prt1_e_2.a + prt1_e_2.b) / 2) = (50)))
+ Hash Cond: (prt1_3.a = ((prt1_e_3.a + prt1_e_3.b) / 2))
+ Filter: ((prt1_3.a = (50)) OR (prt2_3.b = (75)) OR (((prt1_e_3.a + prt1_e_3.b) / 2) = (50)))
-> Hash Full Join
- Hash Cond: (prt1_2.a = prt2_2.b)
- -> Seq Scan on prt1_p3 prt1_2
+ Hash Cond: (prt1_3.a = prt2_3.b)
+ -> Seq Scan on prt1_p3 prt1_3
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p3 prt2_2
+ -> Seq Scan on prt2_p3 prt2_3
Filter: (a = 0)
-> Hash
- -> Seq Scan on prt1_e_p3 prt1_e_2
+ -> Seq Scan on prt1_e_p3 prt1_e_3
Filter: (c = 0)
(42 rows)
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = t1_3.b)
+ Join Filter: (t1_2.a = t1_5.b)
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Join
- Hash Cond: (((t2.a + t2.b) / 2) = t1_3.b)
- -> Seq Scan on prt1_e_p1 t2
+ Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_5.b)
+ -> Seq Scan on prt1_e_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p1 t1_3
+ -> Seq Scan on prt2_p1 t1_5
Filter: (a = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
- Index Cond: (a = ((t2.a + t2.b) / 2))
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_2
+ Index Cond: (a = ((t2_1.a + t2_1.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_1.a = t1_4.b)
+ Join Filter: (t1_3.a = t1_6.b)
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Join
- Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_4.b)
- -> Seq Scan on prt1_e_p2 t2_1
+ Hash Cond: (((t2_2.a + t2_2.b) / 2) = t1_6.b)
+ -> Seq Scan on prt1_e_p2 t2_2
-> Hash
- -> Seq Scan on prt2_p2 t1_4
+ -> Seq Scan on prt2_p2 t1_6
Filter: (a = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
- Index Cond: (a = ((t2_1.a + t2_1.b) / 2))
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_3
+ Index Cond: (a = ((t2_2.a + t2_2.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_2.a = t1_5.b)
+ Join Filter: (t1_4.a = t1_7.b)
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Nested Loop
- -> Seq Scan on prt2_p3 t1_5
+ -> Seq Scan on prt2_p3 t1_7
Filter: (a = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_2
- Index Cond: (((a + b) / 2) = t1_5.b)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = ((t2_2.a + t2_2.b) / 2))
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_3
+ Index Cond: (((a + b) / 2) = t1_7.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_4
+ Index Cond: (a = ((t2_3.a + t2_3.b) / 2))
Filter: (b = 0)
(41 rows)
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
--------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Nested Loop
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_6.b
-> Hash Semi Join
- Hash Cond: (t1_3.b = ((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt2_p1 t1_3
+ Hash Cond: (t1_6.b = ((t1_9.a + t1_9.b) / 2))
+ -> Seq Scan on prt2_p1 t1_6
-> Hash
- -> Seq Scan on prt1_e_p1 t1_6
+ -> Seq Scan on prt1_e_p1 t1_9
Filter: (c = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
- Index Cond: (a = t1_3.b)
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_3
+ Index Cond: (a = t1_6.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_7.b
-> Hash Semi Join
- Hash Cond: (t1_4.b = ((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt2_p2 t1_4
+ Hash Cond: (t1_7.b = ((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt2_p2 t1_7
-> Hash
- -> Seq Scan on prt1_e_p2 t1_7
+ -> Seq Scan on prt1_e_p2 t1_10
Filter: (c = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
- Index Cond: (a = t1_4.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_4
+ Index Cond: (a = t1_7.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_8.b
-> Hash Semi Join
- Hash Cond: (t1_5.b = ((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt2_p3 t1_5
+ Hash Cond: (t1_8.b = ((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt2_p3 t1_8
-> Hash
- -> Seq Scan on prt1_e_p3 t1_8
+ -> Seq Scan on prt1_e_p3 t1_11
Filter: (c = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t1_5.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_5
+ Index Cond: (a = t1_8.b)
Filter: (b = 0)
(39 rows)
SET enable_nestloop TO off;
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------
Merge Append
Sort Key: t1.a
-> Merge Semi Join
- Merge Cond: (t1.a = t1_3.b)
+ Merge Cond: (t1_3.a = t1_6.b)
-> Sort
- Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p1 t1_3
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_3.b = (((t1_6.a + t1_6.b) / 2)))
+ Merge Cond: (t1_6.b = (((t1_9.a + t1_9.b) / 2)))
-> Sort
- Sort Key: t1_3.b
- -> Seq Scan on prt2_p1 t1_3
+ Sort Key: t1_6.b
+ -> Seq Scan on prt2_p1 t1_6
-> Sort
- Sort Key: (((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt1_e_p1 t1_6
+ Sort Key: (((t1_9.a + t1_9.b) / 2))
+ -> Seq Scan on prt1_e_p1 t1_9
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_1.a = t1_4.b)
+ Merge Cond: (t1_4.a = t1_7.b)
-> Sort
- Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p2 t1_4
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_4.b = (((t1_7.a + t1_7.b) / 2)))
+ Merge Cond: (t1_7.b = (((t1_10.a + t1_10.b) / 2)))
-> Sort
- Sort Key: t1_4.b
- -> Seq Scan on prt2_p2 t1_4
+ Sort Key: t1_7.b
+ -> Seq Scan on prt2_p2 t1_7
-> Sort
- Sort Key: (((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt1_e_p2 t1_7
+ Sort Key: (((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt1_e_p2 t1_10
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_2.a = t1_5.b)
+ Merge Cond: (t1_5.a = t1_8.b)
-> Sort
- Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ Sort Key: t1_5.a
+ -> Seq Scan on prt1_p3 t1_5
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_5.b = (((t1_8.a + t1_8.b) / 2)))
+ Merge Cond: (t1_8.b = (((t1_11.a + t1_11.b) / 2)))
-> Sort
- Sort Key: t1_5.b
- -> Seq Scan on prt2_p3 t1_5
+ Sort Key: t1_8.b
+ -> Seq Scan on prt2_p3 t1_8
-> Sort
- Sort Key: (((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt1_e_p3 t1_8
+ Sort Key: (((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt1_e_p3 t1_11
Filter: (c = 0)
(47 rows)
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
- -> Merge Left Join
- Merge Cond: (t1.a = t2.b)
- -> Sort
- Sort Key: t1.a
- -> Merge Left Join
- Merge Cond: ((((t3.a + t3.b) / 2)) = t1.a)
- -> Sort
- Sort Key: (((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_e_p1 t3
- Filter: (c = 0)
- -> Sort
- Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
- -> Sort
- Sort Key: t2.b
- -> Seq Scan on prt2_p1 t2
-> Merge Left Join
Merge Cond: (t1_1.a = t2_1.b)
-> Sort
Merge Cond: ((((t3_1.a + t3_1.b) / 2)) = t1_1.a)
-> Sort
Sort Key: (((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Sort
Sort Key: t2_1.b
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Merge Left Join
Merge Cond: (t1_2.a = t2_2.b)
-> Sort
Merge Cond: ((((t3_2.a + t3_2.b) / 2)) = t1_2.a)
-> Sort
Sort Key: (((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Sort
Sort Key: t2_2.b
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
+ -> Merge Left Join
+ Merge Cond: (t1_3.a = t2_3.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_3.a + t3_3.b) / 2)) = t1_3.a)
+ -> Sort
+ Sort Key: (((t3_3.a + t3_3.b) / 2))
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ -> Sort
+ Sort Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
(51 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
-> Sort
Sort Key: prt1.a
-> Append
- -> Seq Scan on prt1_p1 prt1
+ -> Seq Scan on prt1_p1 prt1_1
Filter: ((a < 450) AND (b = 0))
- -> Seq Scan on prt1_p2 prt1_1
+ -> Seq Scan on prt1_p2 prt1_2
Filter: ((a < 450) AND (b = 0))
-> Sort
Sort Key: prt2.b
-> Append
- -> Seq Scan on prt2_p2 prt2
+ -> Seq Scan on prt2_p2 prt2_1
Filter: (b > 250)
- -> Seq Scan on prt2_p3 prt2_1
+ -> Seq Scan on prt2_p3 prt2_2
Filter: (b > 250)
(18 rows)
Sort Key: t1.a, ((((t1.*)::prt1))::text)
-> Result
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
-> Sort
Sort Key: t2.b, ((((t2.*)::prt2))::text)
-> Result
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
(16 rows)
SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.b ORDER BY t1.a;
Sort Key: prt1_m.a, prt2_m.b
-> Append
-> Hash Full Join
- Hash Cond: ((prt1_m.a = ((prt2_m.b + prt2_m.a) / 2)) AND (((prt1_m.a + prt1_m.b) / 2) = prt2_m.b))
- -> Seq Scan on prt1_m_p1 prt1_m
+ Hash Cond: ((prt1_m_1.a = ((prt2_m_1.b + prt2_m_1.a) / 2)) AND (((prt1_m_1.a + prt1_m_1.b) / 2) = prt2_m_1.b))
+ -> Seq Scan on prt1_m_p1 prt1_m_1
Filter: (c = 0)
-> Hash
- -> Seq Scan on prt2_m_p1 prt2_m
+ -> Seq Scan on prt2_m_p1 prt2_m_1
Filter: (c = 0)
-> Hash Full Join
- Hash Cond: ((prt1_m_1.a = ((prt2_m_1.b + prt2_m_1.a) / 2)) AND (((prt1_m_1.a + prt1_m_1.b) / 2) = prt2_m_1.b))
- -> Seq Scan on prt1_m_p2 prt1_m_1
+ Hash Cond: ((prt1_m_2.a = ((prt2_m_2.b + prt2_m_2.a) / 2)) AND (((prt1_m_2.a + prt1_m_2.b) / 2) = prt2_m_2.b))
+ -> Seq Scan on prt1_m_p2 prt1_m_2
Filter: (c = 0)
-> Hash
- -> Seq Scan on prt2_m_p2 prt2_m_1
+ -> Seq Scan on prt2_m_p2 prt2_m_2
Filter: (c = 0)
-> Hash Full Join
- Hash Cond: ((prt1_m_2.a = ((prt2_m_2.b + prt2_m_2.a) / 2)) AND (((prt1_m_2.a + prt1_m_2.b) / 2) = prt2_m_2.b))
- -> Seq Scan on prt1_m_p3 prt1_m_2
+ Hash Cond: ((prt1_m_3.a = ((prt2_m_3.b + prt2_m_3.a) / 2)) AND (((prt1_m_3.a + prt1_m_3.b) / 2) = prt2_m_3.b))
+ -> Seq Scan on prt1_m_p3 prt1_m_3
Filter: (c = 0)
-> Hash
- -> Seq Scan on prt2_m_p3 prt2_m_2
+ -> Seq Scan on prt2_m_p3 prt2_m_3
Filter: (c = 0)
(24 rows)
-> Sort
Sort Key: t1.c, t3.c
-> Append
- -> Hash Join
- Hash Cond: (t1.c = ltrim(t3.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1.b = t2.b) AND (t1.c = t2.c))
- -> Seq Scan on plt1_p1 t1
- -> Hash
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_e_p1 t3
-> Hash Join
Hash Cond: (t1_1.c = ltrim(t3_1.c, 'A'::text))
-> Hash Join
Hash Cond: ((t1_1.b = t2_1.b) AND (t1_1.c = t2_1.c))
- -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p1 t1_1
-> Hash
- -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p1 t2_1
-> Hash
- -> Seq Scan on plt1_e_p2 t3_1
+ -> Seq Scan on plt1_e_p1 t3_1
-> Hash Join
Hash Cond: (t1_2.c = ltrim(t3_2.c, 'A'::text))
-> Hash Join
Hash Cond: ((t1_2.b = t2_2.b) AND (t1_2.c = t2_2.c))
- -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p2 t1_2
-> Hash
- -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p2 t2_2
-> Hash
- -> Seq Scan on plt1_e_p3 t3_2
+ -> Seq Scan on plt1_e_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t1_3.c = ltrim(t3_3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t1_3.b = t2_3.b) AND (t1_3.c = t2_3.c))
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Seq Scan on plt1_e_p3 t3_3
(32 rows)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Hash Join
- Hash Cond: (t3.a = t2.b)
- -> Seq Scan on prt1_p1 t3
- -> Hash
- -> Seq Scan on prt2_p1 t2
-> Hash Join
Hash Cond: (t3_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t3_1
+ -> Seq Scan on prt1_p1 t3_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash Join
Hash Cond: (t3_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t3_2
+ -> Seq Scan on prt1_p2 t3_2
-> Hash
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: (t3_3.a = t2_3.b)
+ -> Seq Scan on prt1_p3 t3_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_3
-> Hash
-> Result
One-Time Filter: false
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
-> Hash
-> Result
-> Sort
Sort Key: t1.c, t3.c
-> Append
- -> Hash Join
- Hash Cond: (t1.c = ltrim(t3.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1.b = t2.b) AND (t1.c = t2.c))
- -> Seq Scan on pht1_p1 t1
- -> Hash
- -> Seq Scan on pht2_p1 t2
- -> Hash
- -> Seq Scan on pht1_e_p1 t3
-> Hash Join
Hash Cond: (t1_1.c = ltrim(t3_1.c, 'A'::text))
-> Hash Join
Hash Cond: ((t1_1.b = t2_1.b) AND (t1_1.c = t2_1.c))
- -> Seq Scan on pht1_p2 t1_1
+ -> Seq Scan on pht1_p1 t1_1
-> Hash
- -> Seq Scan on pht2_p2 t2_1
+ -> Seq Scan on pht2_p1 t2_1
-> Hash
- -> Seq Scan on pht1_e_p2 t3_1
+ -> Seq Scan on pht1_e_p1 t3_1
-> Hash Join
Hash Cond: (t1_2.c = ltrim(t3_2.c, 'A'::text))
-> Hash Join
Hash Cond: ((t1_2.b = t2_2.b) AND (t1_2.c = t2_2.c))
- -> Seq Scan on pht1_p3 t1_2
+ -> Seq Scan on pht1_p2 t1_2
+ -> Hash
+ -> Seq Scan on pht2_p2 t2_2
+ -> Hash
+ -> Seq Scan on pht1_e_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t1_3.c = ltrim(t3_3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t1_3.b = t2_3.b) AND (t1_3.c = t2_3.c))
+ -> Seq Scan on pht1_p3 t1_3
-> Hash
- -> Seq Scan on pht2_p3 t2_2
+ -> Seq Scan on pht2_p3 t2_3
-> Hash
- -> Seq Scan on pht1_e_p3 t3_2
+ -> Seq Scan on pht1_e_p3 t3_3
(32 rows)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
Sort Key: t1.a
-> Append
-> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Join
- Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Hash Join
- Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ Hash Cond: (t2_3.b = t1_3.a)
+ -> Seq Scan on prt2_p3 t2_3
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p3 t1_3
Filter: (b = 0)
(21 rows)
Group Key: t1.c, t2.c
-> Append
-> Hash Join
- Hash Cond: (t2.c = t1.c)
- -> Seq Scan on plt2_p1 t2
+ Hash Cond: (t2_1.c = t1_1.c)
+ -> Seq Scan on plt2_p1 t2_1
-> Hash
- -> Seq Scan on plt1_p1 t1
+ -> Seq Scan on plt1_p1 t1_1
Filter: ((a % 25) = 0)
-> Hash Join
- Hash Cond: (t2_1.c = t1_1.c)
- -> Seq Scan on plt2_p2 t2_1
+ Hash Cond: (t2_2.c = t1_2.c)
+ -> Seq Scan on plt2_p2 t2_2
-> Hash
- -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p2 t1_2
Filter: ((a % 25) = 0)
-> Hash Join
- Hash Cond: (t2_2.c = t1_2.c)
- -> Seq Scan on plt2_p3 t2_2
+ Hash Cond: (t2_3.c = t1_3.c)
+ -> Seq Scan on plt2_p3 t2_3
-> Hash
- -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p3 t1_3
Filter: ((a % 25) = 0)
(23 rows)
Sort Key: t1.a
-> Append
-> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_l_p1 t2
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_l_p1 t2_1
-> Hash
- -> Seq Scan on prt1_l_p1 t1
+ -> Seq Scan on prt1_l_p1 t1_1
Filter: (b = 0)
-> Hash Join
- Hash Cond: (t2_1.b = t1_1.a)
+ Hash Cond: (t2_3.b = t1_3.a)
-> Append
- -> Seq Scan on prt2_l_p2_p1 t2_1
- -> Seq Scan on prt2_l_p2_p2 t2_2
+ -> Seq Scan on prt2_l_p2_p1 t2_3
+ -> Seq Scan on prt2_l_p2_p2 t2_4
-> Hash
-> Append
- -> Seq Scan on prt1_l_p2_p1 t1_1
+ -> Seq Scan on prt1_l_p2_p1 t1_3
Filter: (b = 0)
- -> Seq Scan on prt1_l_p2_p2 t1_2
+ -> Seq Scan on prt1_l_p2_p2 t1_4
Filter: (b = 0)
-> Hash Join
- Hash Cond: (t2_3.b = t1_3.a)
+ Hash Cond: (t2_6.b = t1_5.a)
-> Append
- -> Seq Scan on prt2_l_p3_p1 t2_3
- -> Seq Scan on prt2_l_p3_p2 t2_4
+ -> Seq Scan on prt2_l_p3_p1 t2_6
+ -> Seq Scan on prt2_l_p3_p2 t2_7
-> Hash
- -> Seq Scan on prt1_l_p3_p1 t1_3
+ -> Seq Scan on prt1_l_p3_p1 t1_5
Filter: (b = 0)
(28 rows)
Sort
Sort Key: t1.a, t2.b
-> Append
- -> Hash Right Join
- Hash Cond: ((t2.b = t1.a) AND ((t2.c)::text = (t1.c)::text))
- -> Seq Scan on prt2_l_p1 t2
- -> Hash
- -> Seq Scan on prt1_l_p1 t1
- Filter: (b = 0)
-> Hash Right Join
Hash Cond: ((t2_1.b = t1_1.a) AND ((t2_1.c)::text = (t1_1.c)::text))
- -> Seq Scan on prt2_l_p2_p1 t2_1
+ -> Seq Scan on prt2_l_p1 t2_1
-> Hash
- -> Seq Scan on prt1_l_p2_p1 t1_1
+ -> Seq Scan on prt1_l_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: ((t2_2.b = t1_2.a) AND ((t2_2.c)::text = (t1_2.c)::text))
- -> Seq Scan on prt2_l_p2_p2 t2_2
+ -> Seq Scan on prt2_l_p2_p1 t2_2
-> Hash
- -> Seq Scan on prt1_l_p2_p2 t1_2
+ -> Seq Scan on prt1_l_p2_p1 t1_2
Filter: (b = 0)
-> Hash Right Join
Hash Cond: ((t2_3.b = t1_3.a) AND ((t2_3.c)::text = (t1_3.c)::text))
+ -> Seq Scan on prt2_l_p2_p2 t2_3
+ -> Hash
+ -> Seq Scan on prt1_l_p2_p2 t1_3
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: ((t2_5.b = t1_4.a) AND ((t2_5.c)::text = (t1_4.c)::text))
-> Append
- -> Seq Scan on prt2_l_p3_p1 t2_3
- -> Seq Scan on prt2_l_p3_p2 t2_4
+ -> Seq Scan on prt2_l_p3_p1 t2_5
+ -> Seq Scan on prt2_l_p3_p2 t2_6
-> Hash
- -> Seq Scan on prt1_l_p3_p1 t1_3
+ -> Seq Scan on prt1_l_p3_p1 t1_4
Filter: (b = 0)
(29 rows)
Sort
Sort Key: t1.a, t2.b
-> Append
- -> Hash Right Join
- Hash Cond: ((t1.a = t2.b) AND ((t1.c)::text = (t2.c)::text))
- -> Seq Scan on prt1_l_p1 t1
- -> Hash
- -> Seq Scan on prt2_l_p1 t2
- Filter: (a = 0)
-> Hash Right Join
Hash Cond: ((t1_1.a = t2_1.b) AND ((t1_1.c)::text = (t2_1.c)::text))
- -> Seq Scan on prt1_l_p2_p1 t1_1
+ -> Seq Scan on prt1_l_p1 t1_1
-> Hash
- -> Seq Scan on prt2_l_p2_p1 t2_1
+ -> Seq Scan on prt2_l_p1 t2_1
Filter: (a = 0)
-> Hash Right Join
Hash Cond: ((t1_2.a = t2_2.b) AND ((t1_2.c)::text = (t2_2.c)::text))
- -> Seq Scan on prt1_l_p2_p2 t1_2
+ -> Seq Scan on prt1_l_p2_p1 t1_2
-> Hash
- -> Seq Scan on prt2_l_p2_p2 t2_2
+ -> Seq Scan on prt2_l_p2_p1 t2_2
Filter: (a = 0)
-> Hash Right Join
Hash Cond: ((t1_3.a = t2_3.b) AND ((t1_3.c)::text = (t2_3.c)::text))
+ -> Seq Scan on prt1_l_p2_p2 t1_3
+ -> Hash
+ -> Seq Scan on prt2_l_p2_p2 t2_3
+ Filter: (a = 0)
+ -> Hash Right Join
+ Hash Cond: ((t1_5.a = t2_4.b) AND ((t1_5.c)::text = (t2_4.c)::text))
-> Append
- -> Seq Scan on prt1_l_p3_p1 t1_3
- -> Seq Scan on prt1_l_p3_p2 t1_4
+ -> Seq Scan on prt1_l_p3_p1 t1_5
+ -> Seq Scan on prt1_l_p3_p2 t1_6
-> Hash
- -> Seq Scan on prt2_l_p3_p1 t2_3
+ -> Seq Scan on prt2_l_p3_p1 t2_4
Filter: (a = 0)
(29 rows)
Sort Key: prt1_l.a, prt2_l.b
-> Append
-> Hash Full Join
- Hash Cond: ((prt1_l.a = prt2_l.b) AND ((prt1_l.c)::text = (prt2_l.c)::text))
- -> Seq Scan on prt1_l_p1 prt1_l
+ Hash Cond: ((prt1_l_1.a = prt2_l_1.b) AND ((prt1_l_1.c)::text = (prt2_l_1.c)::text))
+ -> Seq Scan on prt1_l_p1 prt1_l_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_l_p1 prt2_l
+ -> Seq Scan on prt2_l_p1 prt2_l_1
Filter: (a = 0)
-> Hash Full Join
- Hash Cond: ((prt1_l_1.a = prt2_l_1.b) AND ((prt1_l_1.c)::text = (prt2_l_1.c)::text))
- -> Seq Scan on prt1_l_p2_p1 prt1_l_1
+ Hash Cond: ((prt1_l_2.a = prt2_l_2.b) AND ((prt1_l_2.c)::text = (prt2_l_2.c)::text))
+ -> Seq Scan on prt1_l_p2_p1 prt1_l_2
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_l_p2_p1 prt2_l_1
+ -> Seq Scan on prt2_l_p2_p1 prt2_l_2
Filter: (a = 0)
-> Hash Full Join
- Hash Cond: ((prt1_l_2.a = prt2_l_2.b) AND ((prt1_l_2.c)::text = (prt2_l_2.c)::text))
- -> Seq Scan on prt1_l_p2_p2 prt1_l_2
+ Hash Cond: ((prt1_l_3.a = prt2_l_3.b) AND ((prt1_l_3.c)::text = (prt2_l_3.c)::text))
+ -> Seq Scan on prt1_l_p2_p2 prt1_l_3
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_l_p2_p2 prt2_l_2
+ -> Seq Scan on prt2_l_p2_p2 prt2_l_3
Filter: (a = 0)
-> Hash Full Join
- Hash Cond: ((prt1_l_3.a = prt2_l_3.b) AND ((prt1_l_3.c)::text = (prt2_l_3.c)::text))
- -> Seq Scan on prt1_l_p3_p1 prt1_l_3
+ Hash Cond: ((prt1_l_4.a = prt2_l_4.b) AND ((prt1_l_4.c)::text = (prt2_l_4.c)::text))
+ -> Seq Scan on prt1_l_p3_p1 prt1_l_4
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_l_p3_p1 prt2_l_3
+ -> Seq Scan on prt2_l_p3_p1 prt2_l_4
Filter: (a = 0)
(31 rows)
Sort Key: t1.a
-> Append
-> Nested Loop Left Join
- -> Seq Scan on prt1_l_p1 t1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: ((t3.b = t2.a) AND ((t3.c)::text = (t2.c)::text))
- -> Seq Scan on prt2_l_p1 t3
- -> Hash
- -> Seq Scan on prt1_l_p1 t2
- Filter: ((t1.a = a) AND ((t1.c)::text = (c)::text))
- -> Nested Loop Left Join
- -> Seq Scan on prt1_l_p2_p1 t1_1
+ -> Seq Scan on prt1_l_p1 t1_1
Filter: (b = 0)
-> Hash Join
Hash Cond: ((t3_1.b = t2_1.a) AND ((t3_1.c)::text = (t2_1.c)::text))
- -> Seq Scan on prt2_l_p2_p1 t3_1
+ -> Seq Scan on prt2_l_p1 t3_1
-> Hash
- -> Seq Scan on prt1_l_p2_p1 t2_1
+ -> Seq Scan on prt1_l_p1 t2_1
Filter: ((t1_1.a = a) AND ((t1_1.c)::text = (c)::text))
-> Nested Loop Left Join
- -> Seq Scan on prt1_l_p2_p2 t1_2
+ -> Seq Scan on prt1_l_p2_p1 t1_2
Filter: (b = 0)
-> Hash Join
Hash Cond: ((t3_2.b = t2_2.a) AND ((t3_2.c)::text = (t2_2.c)::text))
- -> Seq Scan on prt2_l_p2_p2 t3_2
+ -> Seq Scan on prt2_l_p2_p1 t3_2
-> Hash
- -> Seq Scan on prt1_l_p2_p2 t2_2
+ -> Seq Scan on prt1_l_p2_p1 t2_2
Filter: ((t1_2.a = a) AND ((t1_2.c)::text = (c)::text))
-> Nested Loop Left Join
- -> Seq Scan on prt1_l_p3_p1 t1_3
+ -> Seq Scan on prt1_l_p2_p2 t1_3
Filter: (b = 0)
-> Hash Join
Hash Cond: ((t3_3.b = t2_3.a) AND ((t3_3.c)::text = (t2_3.c)::text))
+ -> Seq Scan on prt2_l_p2_p2 t3_3
+ -> Hash
+ -> Seq Scan on prt1_l_p2_p2 t2_3
+ Filter: ((t1_3.a = a) AND ((t1_3.c)::text = (c)::text))
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_l_p3_p1 t1_4
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: ((t3_5.b = t2_5.a) AND ((t3_5.c)::text = (t2_5.c)::text))
-> Append
- -> Seq Scan on prt2_l_p3_p1 t3_3
- -> Seq Scan on prt2_l_p3_p2 t3_4
+ -> Seq Scan on prt2_l_p3_p1 t3_5
+ -> Seq Scan on prt2_l_p3_p2 t3_6
-> Hash
-> Append
- -> Seq Scan on prt1_l_p3_p1 t2_3
- Filter: ((t1_3.a = a) AND ((t1_3.c)::text = (c)::text))
- -> Seq Scan on prt1_l_p3_p2 t2_4
- Filter: ((t1_3.a = a) AND ((t1_3.c)::text = (c)::text))
+ -> Seq Scan on prt1_l_p3_p1 t2_5
+ Filter: ((t1_4.a = a) AND ((t1_4.c)::text = (c)::text))
+ -> Seq Scan on prt1_l_p3_p2 t2_6
+ Filter: ((t1_4.a = a) AND ((t1_4.c)::text = (c)::text))
(44 rows)
SELECT * FROM prt1_l t1 LEFT JOIN LATERAL
Hash Left Join
Hash Cond: ((t2.b = a) AND (t2.a = b) AND ((t2.c)::text = (c)::text))
-> Append
- -> Seq Scan on prt2_l_p1 t2
- -> Seq Scan on prt2_l_p2_p1 t2_1
- -> Seq Scan on prt2_l_p2_p2 t2_2
- -> Seq Scan on prt2_l_p3_p1 t2_3
- -> Seq Scan on prt2_l_p3_p2 t2_4
+ -> Seq Scan on prt2_l_p1 t2_1
+ -> Seq Scan on prt2_l_p2_p1 t2_2
+ -> Seq Scan on prt2_l_p2_p2 t2_3
+ -> Seq Scan on prt2_l_p3_p1 t2_4
+ -> Seq Scan on prt2_l_p3_p2 t2_5
-> Hash
-> Result
One-Time Filter: false
Hash Join
Hash Cond: (t1.a = t2.a)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
-> Hash
-> Append
- -> Seq Scan on prt4_n_p1 t2
- -> Seq Scan on prt4_n_p2 t2_1
- -> Seq Scan on prt4_n_p3 t2_2
+ -> Seq Scan on prt4_n_p1 t2_1
+ -> Seq Scan on prt4_n_p2 t2_2
+ -> Seq Scan on prt4_n_p3 t2_3
(11 rows)
EXPLAIN (COSTS OFF)
Hash Join
Hash Cond: (t2.a = t1.a)
-> Append
- -> Seq Scan on prt4_n_p1 t2
- -> Seq Scan on prt4_n_p2 t2_1
- -> Seq Scan on prt4_n_p3 t2_2
+ -> Seq Scan on prt4_n_p1 t2_1
+ -> Seq Scan on prt4_n_p2 t2_2
+ -> Seq Scan on prt4_n_p3 t2_3
-> Hash
-> Append
- -> Hash Join
- Hash Cond: (t1.a = t3.b)
- -> Seq Scan on prt1_p1 t1
- -> Hash
- -> Seq Scan on prt2_p1 t3
-> Hash Join
Hash Cond: (t1_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p1 t3_1
-> Hash Join
Hash Cond: (t1_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t1_3.a = t3_3.b)
+ -> Seq Scan on prt1_p3 t1_3
-> Hash
- -> Seq Scan on prt2_p3 t3_2
+ -> Seq Scan on prt2_p3 t3_3
(23 rows)
-- partitionwise join can not be applied if there are no equi-join conditions
---------------------------------------------------------
Nested Loop Left Join
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
-> Append
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
+ -> Index Scan using iprt2_p1_b on prt2_p1 t2_1
Index Cond: (b > t1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
+ -> Index Scan using iprt2_p2_b on prt2_p2 t2_2
Index Cond: (b > t1.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
Index Cond: (b > t1.a)
(12 rows)
Hash Join
Hash Cond: (((t2.b + t2.a) / 2) = t1.a)
-> Append
- -> Seq Scan on prt2_m_p1 t2
- -> Seq Scan on prt2_m_p2 t2_1
- -> Seq Scan on prt2_m_p3 t2_2
+ -> Seq Scan on prt2_m_p1 t2_1
+ -> Seq Scan on prt2_m_p2 t2_2
+ -> Seq Scan on prt2_m_p3 t2_3
-> Hash
-> Append
- -> Seq Scan on prt1_m_p1 t1
- -> Seq Scan on prt1_m_p2 t1_1
- -> Seq Scan on prt1_m_p3 t1_2
+ -> Seq Scan on prt1_m_p1 t1_1
+ -> Seq Scan on prt1_m_p2 t1_2
+ -> Seq Scan on prt1_m_p3 t1_3
(11 rows)
-- equi-join between out-of-order partition key columns does not qualify for
Hash Left Join
Hash Cond: (t1.a = t2.b)
-> Append
- -> Seq Scan on prt1_m_p1 t1
- -> Seq Scan on prt1_m_p2 t1_1
- -> Seq Scan on prt1_m_p3 t1_2
+ -> Seq Scan on prt1_m_p1 t1_1
+ -> Seq Scan on prt1_m_p2 t1_2
+ -> Seq Scan on prt1_m_p3 t1_3
-> Hash
-> Append
- -> Seq Scan on prt2_m_p1 t2
- -> Seq Scan on prt2_m_p2 t2_1
- -> Seq Scan on prt2_m_p3 t2_2
+ -> Seq Scan on prt2_m_p1 t2_1
+ -> Seq Scan on prt2_m_p2 t2_2
+ -> Seq Scan on prt2_m_p3 t2_3
(11 rows)
-- equi-join between non-key columns does not qualify for partitionwise join
Hash Left Join
Hash Cond: (t1.c = t2.c)
-> Append
- -> Seq Scan on prt1_m_p1 t1
- -> Seq Scan on prt1_m_p2 t1_1
- -> Seq Scan on prt1_m_p3 t1_2
+ -> Seq Scan on prt1_m_p1 t1_1
+ -> Seq Scan on prt1_m_p2 t1_2
+ -> Seq Scan on prt1_m_p3 t1_3
-> Hash
-> Append
- -> Seq Scan on prt2_m_p1 t2
- -> Seq Scan on prt2_m_p2 t2_1
- -> Seq Scan on prt2_m_p3 t2_2
+ -> Seq Scan on prt2_m_p1 t2_1
+ -> Seq Scan on prt2_m_p2 t2_2
+ -> Seq Scan on prt2_m_p3 t2_3
(11 rows)
-- partitionwise join can not be applied between tables with different
Hash Right Join
Hash Cond: (t2.c = (t1.c)::text)
-> Append
- -> Seq Scan on prt2_n_p1 t2
- -> Seq Scan on prt2_n_p2 t2_1
+ -> Seq Scan on prt2_n_p1 t2_1
+ -> Seq Scan on prt2_n_p2 t2_2
-> Hash
-> Append
- -> Seq Scan on prt1_n_p1 t1
- -> Seq Scan on prt1_n_p2 t1_1
+ -> Seq Scan on prt1_n_p1 t1_1
+ -> Seq Scan on prt1_n_p2 t1_2
(9 rows)
EXPLAIN (COSTS OFF)
Hash Join
Hash Cond: (t2.c = (t1.c)::text)
-> Append
- -> Seq Scan on prt2_n_p1 t2
- -> Seq Scan on prt2_n_p2 t2_1
+ -> Seq Scan on prt2_n_p1 t2_1
+ -> Seq Scan on prt2_n_p2 t2_2
-> Hash
-> Hash Join
Hash Cond: (t3.c = (t1.c)::text)
-> Append
- -> Seq Scan on plt1_p1 t3
- -> Seq Scan on plt1_p2 t3_1
- -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p1 t3_1
+ -> Seq Scan on plt1_p2 t3_2
+ -> Seq Scan on plt1_p3 t3_3
-> Hash
-> Append
- -> Seq Scan on prt1_n_p1 t1
- -> Seq Scan on prt1_n_p2 t1_1
+ -> Seq Scan on prt1_n_p1 t1_1
+ -> Seq Scan on prt1_n_p2 t1_2
(16 rows)
-- partitionwise join can not be applied for a join between list and range
Hash Full Join
Hash Cond: ((t2.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on prt1_p1 t2
- -> Seq Scan on prt1_p2 t2_1
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
-> Hash
-> Append
- -> Seq Scan on prt1_n_p1 t1
- -> Seq Scan on prt1_n_p2 t1_1
+ -> Seq Scan on prt1_n_p1 t1_1
+ -> Seq Scan on prt1_n_p2 t1_2
(10 rows)
-- partitionwise join can not be applied if only one of joining tables has
-> Hash Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p3 t1_3
Filter: (b = 0)
(16 rows)
QUERY PLAN
-----------------------------------
Append
- -> Seq Scan on lp_ad lp
- -> Seq Scan on lp_bc lp_1
- -> Seq Scan on lp_ef lp_2
- -> Seq Scan on lp_g lp_3
- -> Seq Scan on lp_null lp_4
- -> Seq Scan on lp_default lp_5
+ -> Seq Scan on lp_ad lp_1
+ -> Seq Scan on lp_bc lp_2
+ -> Seq Scan on lp_ef lp_3
+ -> Seq Scan on lp_g lp_4
+ -> Seq Scan on lp_null lp_5
+ -> Seq Scan on lp_default lp_6
(7 rows)
explain (costs off) select * from lp where a > 'a' and a < 'd';
QUERY PLAN
-----------------------------------------------------------
Append
- -> Seq Scan on lp_bc lp
+ -> Seq Scan on lp_bc lp_1
Filter: ((a > 'a'::bpchar) AND (a < 'd'::bpchar))
- -> Seq Scan on lp_default lp_1
+ -> Seq Scan on lp_default lp_2
Filter: ((a > 'a'::bpchar) AND (a < 'd'::bpchar))
(5 rows)
QUERY PLAN
------------------------------------------------------------
Append
- -> Seq Scan on lp_ad lp
+ -> Seq Scan on lp_ad lp_1
Filter: ((a > 'a'::bpchar) AND (a <= 'd'::bpchar))
- -> Seq Scan on lp_bc lp_1
+ -> Seq Scan on lp_bc lp_2
Filter: ((a > 'a'::bpchar) AND (a <= 'd'::bpchar))
- -> Seq Scan on lp_default lp_2
+ -> Seq Scan on lp_default lp_3
Filter: ((a > 'a'::bpchar) AND (a <= 'd'::bpchar))
(7 rows)
QUERY PLAN
-----------------------------------
Append
- -> Seq Scan on lp_ad lp
+ -> Seq Scan on lp_ad lp_1
Filter: (a IS NOT NULL)
- -> Seq Scan on lp_bc lp_1
+ -> Seq Scan on lp_bc lp_2
Filter: (a IS NOT NULL)
- -> Seq Scan on lp_ef lp_2
+ -> Seq Scan on lp_ef lp_3
Filter: (a IS NOT NULL)
- -> Seq Scan on lp_g lp_3
+ -> Seq Scan on lp_g lp_4
Filter: (a IS NOT NULL)
- -> Seq Scan on lp_default lp_4
+ -> Seq Scan on lp_default lp_5
Filter: (a IS NOT NULL)
(11 rows)
QUERY PLAN
----------------------------------------------------------
Append
- -> Seq Scan on lp_ad lp
+ -> Seq Scan on lp_ad lp_1
Filter: ((a = 'a'::bpchar) OR (a = 'c'::bpchar))
- -> Seq Scan on lp_bc lp_1
+ -> Seq Scan on lp_bc lp_2
Filter: ((a = 'a'::bpchar) OR (a = 'c'::bpchar))
(5 rows)
QUERY PLAN
--------------------------------------------------------------------------------
Append
- -> Seq Scan on lp_ad lp
+ -> Seq Scan on lp_ad lp_1
Filter: ((a IS NOT NULL) AND ((a = 'a'::bpchar) OR (a = 'c'::bpchar)))
- -> Seq Scan on lp_bc lp_1
+ -> Seq Scan on lp_bc lp_2
Filter: ((a IS NOT NULL) AND ((a = 'a'::bpchar) OR (a = 'c'::bpchar)))
(5 rows)
QUERY PLAN
------------------------------------
Append
- -> Seq Scan on lp_ad lp
+ -> Seq Scan on lp_ad lp_1
Filter: (a <> 'g'::bpchar)
- -> Seq Scan on lp_bc lp_1
+ -> Seq Scan on lp_bc lp_2
Filter: (a <> 'g'::bpchar)
- -> Seq Scan on lp_ef lp_2
+ -> Seq Scan on lp_ef lp_3
Filter: (a <> 'g'::bpchar)
- -> Seq Scan on lp_default lp_3
+ -> Seq Scan on lp_default lp_4
Filter: (a <> 'g'::bpchar)
(9 rows)
QUERY PLAN
-------------------------------------------------------------
Append
- -> Seq Scan on lp_bc lp
+ -> Seq Scan on lp_bc lp_1
Filter: ((a <> 'a'::bpchar) AND (a <> 'd'::bpchar))
- -> Seq Scan on lp_ef lp_1
+ -> Seq Scan on lp_ef lp_2
Filter: ((a <> 'a'::bpchar) AND (a <> 'd'::bpchar))
- -> Seq Scan on lp_g lp_2
+ -> Seq Scan on lp_g lp_3
Filter: ((a <> 'a'::bpchar) AND (a <> 'd'::bpchar))
- -> Seq Scan on lp_default lp_3
+ -> Seq Scan on lp_default lp_4
Filter: ((a <> 'a'::bpchar) AND (a <> 'd'::bpchar))
(9 rows)
QUERY PLAN
------------------------------------------------
Append
- -> Seq Scan on lp_bc lp
+ -> Seq Scan on lp_bc lp_1
Filter: (a <> ALL ('{a,d}'::bpchar[]))
- -> Seq Scan on lp_ef lp_1
+ -> Seq Scan on lp_ef lp_2
Filter: (a <> ALL ('{a,d}'::bpchar[]))
- -> Seq Scan on lp_g lp_2
+ -> Seq Scan on lp_g lp_3
Filter: (a <> ALL ('{a,d}'::bpchar[]))
- -> Seq Scan on lp_default lp_3
+ -> Seq Scan on lp_default lp_4
Filter: (a <> ALL ('{a,d}'::bpchar[]))
(9 rows)
QUERY PLAN
---------------------------------------------------------
Append
- -> Seq Scan on coll_pruning_a coll_pruning
+ -> Seq Scan on coll_pruning_a coll_pruning_1
Filter: ((a)::text = 'a'::text COLLATE "POSIX")
- -> Seq Scan on coll_pruning_b coll_pruning_1
+ -> Seq Scan on coll_pruning_b coll_pruning_2
Filter: ((a)::text = 'a'::text COLLATE "POSIX")
- -> Seq Scan on coll_pruning_def coll_pruning_2
+ -> Seq Scan on coll_pruning_def coll_pruning_3
Filter: ((a)::text = 'a'::text COLLATE "POSIX")
(7 rows)
QUERY PLAN
------------------------------
Append
- -> Seq Scan on rlp1 rlp
+ -> Seq Scan on rlp1 rlp_1
Filter: (a <= 1)
- -> Seq Scan on rlp2 rlp_1
+ -> Seq Scan on rlp2 rlp_2
Filter: (a <= 1)
(5 rows)
QUERY PLAN
-----------------------------------------------
Append
- -> Seq Scan on rlp1 rlp
+ -> Seq Scan on rlp1 rlp_1
Filter: ((a)::numeric = '1'::numeric)
- -> Seq Scan on rlp2 rlp_1
+ -> Seq Scan on rlp2 rlp_2
Filter: ((a)::numeric = '1'::numeric)
- -> Seq Scan on rlp3abcd rlp_2
+ -> Seq Scan on rlp3abcd rlp_3
Filter: ((a)::numeric = '1'::numeric)
- -> Seq Scan on rlp3efgh rlp_3
+ -> Seq Scan on rlp3efgh rlp_4
Filter: ((a)::numeric = '1'::numeric)
- -> Seq Scan on rlp3nullxy rlp_4
+ -> Seq Scan on rlp3nullxy rlp_5
Filter: ((a)::numeric = '1'::numeric)
- -> Seq Scan on rlp3_default rlp_5
+ -> Seq Scan on rlp3_default rlp_6
Filter: ((a)::numeric = '1'::numeric)
- -> Seq Scan on rlp4_1 rlp_6
+ -> Seq Scan on rlp4_1 rlp_7
Filter: ((a)::numeric = '1'::numeric)
- -> Seq Scan on rlp4_2 rlp_7
+ -> Seq Scan on rlp4_2 rlp_8
Filter: ((a)::numeric = '1'::numeric)
- -> Seq Scan on rlp4_default rlp_8
+ -> Seq Scan on rlp4_default rlp_9
Filter: ((a)::numeric = '1'::numeric)
- -> Seq Scan on rlp5_1 rlp_9
+ -> Seq Scan on rlp5_1 rlp_10
Filter: ((a)::numeric = '1'::numeric)
- -> Seq Scan on rlp5_default rlp_10
+ -> Seq Scan on rlp5_default rlp_11
Filter: ((a)::numeric = '1'::numeric)
- -> Seq Scan on rlp_default_10 rlp_11
+ -> Seq Scan on rlp_default_10 rlp_12
Filter: ((a)::numeric = '1'::numeric)
- -> Seq Scan on rlp_default_30 rlp_12
+ -> Seq Scan on rlp_default_30 rlp_13
Filter: ((a)::numeric = '1'::numeric)
- -> Seq Scan on rlp_default_null rlp_13
+ -> Seq Scan on rlp_default_null rlp_14
Filter: ((a)::numeric = '1'::numeric)
- -> Seq Scan on rlp_default_default rlp_14
+ -> Seq Scan on rlp_default_default rlp_15
Filter: ((a)::numeric = '1'::numeric)
(31 rows)
QUERY PLAN
---------------------------------------------
Append
- -> Seq Scan on rlp1 rlp
+ -> Seq Scan on rlp1 rlp_1
Filter: (a <= 10)
- -> Seq Scan on rlp2 rlp_1
+ -> Seq Scan on rlp2 rlp_2
Filter: (a <= 10)
- -> Seq Scan on rlp_default_10 rlp_2
+ -> Seq Scan on rlp_default_10 rlp_3
Filter: (a <= 10)
- -> Seq Scan on rlp_default_default rlp_3
+ -> Seq Scan on rlp_default_default rlp_4
Filter: (a <= 10)
(9 rows)
QUERY PLAN
----------------------------------------------
Append
- -> Seq Scan on rlp3abcd rlp
+ -> Seq Scan on rlp3abcd rlp_1
Filter: (a > 10)
- -> Seq Scan on rlp3efgh rlp_1
+ -> Seq Scan on rlp3efgh rlp_2
Filter: (a > 10)
- -> Seq Scan on rlp3nullxy rlp_2
+ -> Seq Scan on rlp3nullxy rlp_3
Filter: (a > 10)
- -> Seq Scan on rlp3_default rlp_3
+ -> Seq Scan on rlp3_default rlp_4
Filter: (a > 10)
- -> Seq Scan on rlp4_1 rlp_4
+ -> Seq Scan on rlp4_1 rlp_5
Filter: (a > 10)
- -> Seq Scan on rlp4_2 rlp_5
+ -> Seq Scan on rlp4_2 rlp_6
Filter: (a > 10)
- -> Seq Scan on rlp4_default rlp_6
+ -> Seq Scan on rlp4_default rlp_7
Filter: (a > 10)
- -> Seq Scan on rlp5_1 rlp_7
+ -> Seq Scan on rlp5_1 rlp_8
Filter: (a > 10)
- -> Seq Scan on rlp5_default rlp_8
+ -> Seq Scan on rlp5_default rlp_9
Filter: (a > 10)
- -> Seq Scan on rlp_default_30 rlp_9
+ -> Seq Scan on rlp_default_30 rlp_10
Filter: (a > 10)
- -> Seq Scan on rlp_default_default rlp_10
+ -> Seq Scan on rlp_default_default rlp_11
Filter: (a > 10)
(23 rows)
QUERY PLAN
---------------------------------------------
Append
- -> Seq Scan on rlp1 rlp
+ -> Seq Scan on rlp1 rlp_1
Filter: (a < 15)
- -> Seq Scan on rlp2 rlp_1
+ -> Seq Scan on rlp2 rlp_2
Filter: (a < 15)
- -> Seq Scan on rlp_default_10 rlp_2
+ -> Seq Scan on rlp_default_10 rlp_3
Filter: (a < 15)
- -> Seq Scan on rlp_default_default rlp_3
+ -> Seq Scan on rlp_default_default rlp_4
Filter: (a < 15)
(9 rows)
QUERY PLAN
---------------------------------------------
Append
- -> Seq Scan on rlp1 rlp
+ -> Seq Scan on rlp1 rlp_1
Filter: (a <= 15)
- -> Seq Scan on rlp2 rlp_1
+ -> Seq Scan on rlp2 rlp_2
Filter: (a <= 15)
- -> Seq Scan on rlp3abcd rlp_2
+ -> Seq Scan on rlp3abcd rlp_3
Filter: (a <= 15)
- -> Seq Scan on rlp3efgh rlp_3
+ -> Seq Scan on rlp3efgh rlp_4
Filter: (a <= 15)
- -> Seq Scan on rlp3nullxy rlp_4
+ -> Seq Scan on rlp3nullxy rlp_5
Filter: (a <= 15)
- -> Seq Scan on rlp3_default rlp_5
+ -> Seq Scan on rlp3_default rlp_6
Filter: (a <= 15)
- -> Seq Scan on rlp_default_10 rlp_6
+ -> Seq Scan on rlp_default_10 rlp_7
Filter: (a <= 15)
- -> Seq Scan on rlp_default_default rlp_7
+ -> Seq Scan on rlp_default_default rlp_8
Filter: (a <= 15)
(17 rows)
QUERY PLAN
---------------------------------------------------------
Append
- -> Seq Scan on rlp3abcd rlp
+ -> Seq Scan on rlp3abcd rlp_1
Filter: ((a > 15) AND ((b)::text = 'ab'::text))
- -> Seq Scan on rlp4_1 rlp_1
+ -> Seq Scan on rlp4_1 rlp_2
Filter: ((a > 15) AND ((b)::text = 'ab'::text))
- -> Seq Scan on rlp4_2 rlp_2
+ -> Seq Scan on rlp4_2 rlp_3
Filter: ((a > 15) AND ((b)::text = 'ab'::text))
- -> Seq Scan on rlp4_default rlp_3
+ -> Seq Scan on rlp4_default rlp_4
Filter: ((a > 15) AND ((b)::text = 'ab'::text))
- -> Seq Scan on rlp5_1 rlp_4
+ -> Seq Scan on rlp5_1 rlp_5
Filter: ((a > 15) AND ((b)::text = 'ab'::text))
- -> Seq Scan on rlp5_default rlp_5
+ -> Seq Scan on rlp5_default rlp_6
Filter: ((a > 15) AND ((b)::text = 'ab'::text))
- -> Seq Scan on rlp_default_30 rlp_6
+ -> Seq Scan on rlp_default_30 rlp_7
Filter: ((a > 15) AND ((b)::text = 'ab'::text))
- -> Seq Scan on rlp_default_default rlp_7
+ -> Seq Scan on rlp_default_default rlp_8
Filter: ((a > 15) AND ((b)::text = 'ab'::text))
(17 rows)
QUERY PLAN
--------------------------------------
Append
- -> Seq Scan on rlp3abcd rlp
+ -> Seq Scan on rlp3abcd rlp_1
Filter: (a = 16)
- -> Seq Scan on rlp3efgh rlp_1
+ -> Seq Scan on rlp3efgh rlp_2
Filter: (a = 16)
- -> Seq Scan on rlp3nullxy rlp_2
+ -> Seq Scan on rlp3nullxy rlp_3
Filter: (a = 16)
- -> Seq Scan on rlp3_default rlp_3
+ -> Seq Scan on rlp3_default rlp_4
Filter: (a = 16)
(9 rows)
QUERY PLAN
----------------------------------------------------------
Append
- -> Seq Scan on rlp3abcd rlp
+ -> Seq Scan on rlp3abcd rlp_1
Filter: (((b)::text <= 'ab'::text) AND (a = 16))
- -> Seq Scan on rlp3_default rlp_1
+ -> Seq Scan on rlp3_default rlp_2
Filter: (((b)::text <= 'ab'::text) AND (a = 16))
(5 rows)
QUERY PLAN
------------------------------------------------
Append
- -> Seq Scan on rlp3abcd rlp
+ -> Seq Scan on rlp3abcd rlp_1
Filter: ((b IS NOT NULL) AND (a = 16))
- -> Seq Scan on rlp3efgh rlp_1
+ -> Seq Scan on rlp3efgh rlp_2
Filter: ((b IS NOT NULL) AND (a = 16))
- -> Seq Scan on rlp3nullxy rlp_2
+ -> Seq Scan on rlp3nullxy rlp_3
Filter: ((b IS NOT NULL) AND (a = 16))
- -> Seq Scan on rlp3_default rlp_3
+ -> Seq Scan on rlp3_default rlp_4
Filter: ((b IS NOT NULL) AND (a = 16))
(9 rows)
QUERY PLAN
----------------------------------------------
Append
- -> Seq Scan on rlp1 rlp
+ -> Seq Scan on rlp1 rlp_1
Filter: (a IS NOT NULL)
- -> Seq Scan on rlp2 rlp_1
+ -> Seq Scan on rlp2 rlp_2
Filter: (a IS NOT NULL)
- -> Seq Scan on rlp3abcd rlp_2
+ -> Seq Scan on rlp3abcd rlp_3
Filter: (a IS NOT NULL)
- -> Seq Scan on rlp3efgh rlp_3
+ -> Seq Scan on rlp3efgh rlp_4
Filter: (a IS NOT NULL)
- -> Seq Scan on rlp3nullxy rlp_4
+ -> Seq Scan on rlp3nullxy rlp_5
Filter: (a IS NOT NULL)
- -> Seq Scan on rlp3_default rlp_5
+ -> Seq Scan on rlp3_default rlp_6
Filter: (a IS NOT NULL)
- -> Seq Scan on rlp4_1 rlp_6
+ -> Seq Scan on rlp4_1 rlp_7
Filter: (a IS NOT NULL)
- -> Seq Scan on rlp4_2 rlp_7
+ -> Seq Scan on rlp4_2 rlp_8
Filter: (a IS NOT NULL)
- -> Seq Scan on rlp4_default rlp_8
+ -> Seq Scan on rlp4_default rlp_9
Filter: (a IS NOT NULL)
- -> Seq Scan on rlp5_1 rlp_9
+ -> Seq Scan on rlp5_1 rlp_10
Filter: (a IS NOT NULL)
- -> Seq Scan on rlp5_default rlp_10
+ -> Seq Scan on rlp5_default rlp_11
Filter: (a IS NOT NULL)
- -> Seq Scan on rlp_default_10 rlp_11
+ -> Seq Scan on rlp_default_10 rlp_12
Filter: (a IS NOT NULL)
- -> Seq Scan on rlp_default_30 rlp_12
+ -> Seq Scan on rlp_default_30 rlp_13
Filter: (a IS NOT NULL)
- -> Seq Scan on rlp_default_default rlp_13
+ -> Seq Scan on rlp_default_default rlp_14
Filter: (a IS NOT NULL)
(29 rows)
QUERY PLAN
---------------------------------------------
Append
- -> Seq Scan on rlp5_1 rlp
+ -> Seq Scan on rlp5_1 rlp_1
Filter: (a > 30)
- -> Seq Scan on rlp5_default rlp_1
+ -> Seq Scan on rlp5_default rlp_2
Filter: (a > 30)
- -> Seq Scan on rlp_default_default rlp_2
+ -> Seq Scan on rlp_default_default rlp_3
Filter: (a > 30)
(7 rows)
QUERY PLAN
----------------------------------------------
Append
- -> Seq Scan on rlp1 rlp
+ -> Seq Scan on rlp1 rlp_1
Filter: (a <= 31)
- -> Seq Scan on rlp2 rlp_1
+ -> Seq Scan on rlp2 rlp_2
Filter: (a <= 31)
- -> Seq Scan on rlp3abcd rlp_2
+ -> Seq Scan on rlp3abcd rlp_3
Filter: (a <= 31)
- -> Seq Scan on rlp3efgh rlp_3
+ -> Seq Scan on rlp3efgh rlp_4
Filter: (a <= 31)
- -> Seq Scan on rlp3nullxy rlp_4
+ -> Seq Scan on rlp3nullxy rlp_5
Filter: (a <= 31)
- -> Seq Scan on rlp3_default rlp_5
+ -> Seq Scan on rlp3_default rlp_6
Filter: (a <= 31)
- -> Seq Scan on rlp4_1 rlp_6
+ -> Seq Scan on rlp4_1 rlp_7
Filter: (a <= 31)
- -> Seq Scan on rlp4_2 rlp_7
+ -> Seq Scan on rlp4_2 rlp_8
Filter: (a <= 31)
- -> Seq Scan on rlp4_default rlp_8
+ -> Seq Scan on rlp4_default rlp_9
Filter: (a <= 31)
- -> Seq Scan on rlp5_1 rlp_9
+ -> Seq Scan on rlp5_1 rlp_10
Filter: (a <= 31)
- -> Seq Scan on rlp_default_10 rlp_10
+ -> Seq Scan on rlp_default_10 rlp_11
Filter: (a <= 31)
- -> Seq Scan on rlp_default_30 rlp_11
+ -> Seq Scan on rlp_default_30 rlp_12
Filter: (a <= 31)
- -> Seq Scan on rlp_default_default rlp_12
+ -> Seq Scan on rlp_default_default rlp_13
Filter: (a <= 31)
(27 rows)
QUERY PLAN
-------------------------------------------------------
Append
- -> Seq Scan on rlp1 rlp
+ -> Seq Scan on rlp1 rlp_1
Filter: ((a = 1) OR ((b)::text = 'ab'::text))
- -> Seq Scan on rlp2 rlp_1
+ -> Seq Scan on rlp2 rlp_2
Filter: ((a = 1) OR ((b)::text = 'ab'::text))
- -> Seq Scan on rlp3abcd rlp_2
+ -> Seq Scan on rlp3abcd rlp_3
Filter: ((a = 1) OR ((b)::text = 'ab'::text))
- -> Seq Scan on rlp4_1 rlp_3
+ -> Seq Scan on rlp4_1 rlp_4
Filter: ((a = 1) OR ((b)::text = 'ab'::text))
- -> Seq Scan on rlp4_2 rlp_4
+ -> Seq Scan on rlp4_2 rlp_5
Filter: ((a = 1) OR ((b)::text = 'ab'::text))
- -> Seq Scan on rlp4_default rlp_5
+ -> Seq Scan on rlp4_default rlp_6
Filter: ((a = 1) OR ((b)::text = 'ab'::text))
- -> Seq Scan on rlp5_1 rlp_6
+ -> Seq Scan on rlp5_1 rlp_7
Filter: ((a = 1) OR ((b)::text = 'ab'::text))
- -> Seq Scan on rlp5_default rlp_7
+ -> Seq Scan on rlp5_default rlp_8
Filter: ((a = 1) OR ((b)::text = 'ab'::text))
- -> Seq Scan on rlp_default_10 rlp_8
+ -> Seq Scan on rlp_default_10 rlp_9
Filter: ((a = 1) OR ((b)::text = 'ab'::text))
- -> Seq Scan on rlp_default_30 rlp_9
+ -> Seq Scan on rlp_default_30 rlp_10
Filter: ((a = 1) OR ((b)::text = 'ab'::text))
- -> Seq Scan on rlp_default_null rlp_10
+ -> Seq Scan on rlp_default_null rlp_11
Filter: ((a = 1) OR ((b)::text = 'ab'::text))
- -> Seq Scan on rlp_default_default rlp_11
+ -> Seq Scan on rlp_default_default rlp_12
Filter: ((a = 1) OR ((b)::text = 'ab'::text))
(25 rows)
QUERY PLAN
-----------------------------------------
Append
- -> Seq Scan on rlp4_1 rlp
+ -> Seq Scan on rlp4_1 rlp_1
Filter: ((a > 20) AND (a < 27))
- -> Seq Scan on rlp4_2 rlp_1
+ -> Seq Scan on rlp4_2 rlp_2
Filter: ((a > 20) AND (a < 27))
(5 rows)
QUERY PLAN
---------------------------------------------
Append
- -> Seq Scan on rlp4_default rlp
+ -> Seq Scan on rlp4_default rlp_1
Filter: (a >= 29)
- -> Seq Scan on rlp5_1 rlp_1
+ -> Seq Scan on rlp5_1 rlp_2
Filter: (a >= 29)
- -> Seq Scan on rlp5_default rlp_2
+ -> Seq Scan on rlp5_default rlp_3
Filter: (a >= 29)
- -> Seq Scan on rlp_default_30 rlp_3
+ -> Seq Scan on rlp_default_30 rlp_4
Filter: (a >= 29)
- -> Seq Scan on rlp_default_default rlp_4
+ -> Seq Scan on rlp_default_default rlp_5
Filter: (a >= 29)
(11 rows)
QUERY PLAN
------------------------------------------------------
Append
- -> Seq Scan on rlp1 rlp
+ -> Seq Scan on rlp1 rlp_1
Filter: ((a < 1) OR ((a > 20) AND (a < 25)))
- -> Seq Scan on rlp4_1 rlp_1
+ -> Seq Scan on rlp4_1 rlp_2
Filter: ((a < 1) OR ((a > 20) AND (a < 25)))
(5 rows)
QUERY PLAN
----------------------------------------
Append
- -> Seq Scan on rlp4_1 rlp
+ -> Seq Scan on rlp4_1 rlp_1
Filter: ((a = 20) OR (a = 40))
- -> Seq Scan on rlp5_default rlp_1
+ -> Seq Scan on rlp5_default rlp_2
Filter: ((a = 20) OR (a = 40))
(5 rows)
QUERY PLAN
----------------------------------------------
Append
- -> Seq Scan on rlp3abcd rlp
+ -> Seq Scan on rlp3abcd rlp_1
Filter: ((a > 1) AND (a >= 15))
- -> Seq Scan on rlp3efgh rlp_1
+ -> Seq Scan on rlp3efgh rlp_2
Filter: ((a > 1) AND (a >= 15))
- -> Seq Scan on rlp3nullxy rlp_2
+ -> Seq Scan on rlp3nullxy rlp_3
Filter: ((a > 1) AND (a >= 15))
- -> Seq Scan on rlp3_default rlp_3
+ -> Seq Scan on rlp3_default rlp_4
Filter: ((a > 1) AND (a >= 15))
- -> Seq Scan on rlp4_1 rlp_4
+ -> Seq Scan on rlp4_1 rlp_5
Filter: ((a > 1) AND (a >= 15))
- -> Seq Scan on rlp4_2 rlp_5
+ -> Seq Scan on rlp4_2 rlp_6
Filter: ((a > 1) AND (a >= 15))
- -> Seq Scan on rlp4_default rlp_6
+ -> Seq Scan on rlp4_default rlp_7
Filter: ((a > 1) AND (a >= 15))
- -> Seq Scan on rlp5_1 rlp_7
+ -> Seq Scan on rlp5_1 rlp_8
Filter: ((a > 1) AND (a >= 15))
- -> Seq Scan on rlp5_default rlp_8
+ -> Seq Scan on rlp5_default rlp_9
Filter: ((a > 1) AND (a >= 15))
- -> Seq Scan on rlp_default_30 rlp_9
+ -> Seq Scan on rlp_default_30 rlp_10
Filter: ((a > 1) AND (a >= 15))
- -> Seq Scan on rlp_default_default rlp_10
+ -> Seq Scan on rlp_default_default rlp_11
Filter: ((a > 1) AND (a >= 15))
(23 rows)
QUERY PLAN
-------------------------------------------------------------------
Append
- -> Seq Scan on rlp2 rlp
+ -> Seq Scan on rlp2 rlp_1
Filter: (((a = 1) AND (a = 3)) OR ((a > 1) AND (a = 15)))
- -> Seq Scan on rlp3abcd rlp_1
+ -> Seq Scan on rlp3abcd rlp_2
Filter: (((a = 1) AND (a = 3)) OR ((a > 1) AND (a = 15)))
- -> Seq Scan on rlp3efgh rlp_2
+ -> Seq Scan on rlp3efgh rlp_3
Filter: (((a = 1) AND (a = 3)) OR ((a > 1) AND (a = 15)))
- -> Seq Scan on rlp3nullxy rlp_3
+ -> Seq Scan on rlp3nullxy rlp_4
Filter: (((a = 1) AND (a = 3)) OR ((a > 1) AND (a = 15)))
- -> Seq Scan on rlp3_default rlp_4
+ -> Seq Scan on rlp3_default rlp_5
Filter: (((a = 1) AND (a = 3)) OR ((a > 1) AND (a = 15)))
(11 rows)
QUERY PLAN
---------------------------------------
Append
- -> Seq Scan on mc3p0 mc3p
+ -> Seq Scan on mc3p0 mc3p_1
Filter: (a = 1)
- -> Seq Scan on mc3p1 mc3p_1
+ -> Seq Scan on mc3p1 mc3p_2
Filter: (a = 1)
- -> Seq Scan on mc3p_default mc3p_2
+ -> Seq Scan on mc3p_default mc3p_3
Filter: (a = 1)
(7 rows)
QUERY PLAN
--------------------------------------------
Append
- -> Seq Scan on mc3p0 mc3p
+ -> Seq Scan on mc3p0 mc3p_1
Filter: ((a = 1) AND (abs(b) < 1))
- -> Seq Scan on mc3p_default mc3p_1
+ -> Seq Scan on mc3p_default mc3p_2
Filter: ((a = 1) AND (abs(b) < 1))
(5 rows)
QUERY PLAN
--------------------------------------------
Append
- -> Seq Scan on mc3p0 mc3p
+ -> Seq Scan on mc3p0 mc3p_1
Filter: ((a = 1) AND (abs(b) = 1))
- -> Seq Scan on mc3p1 mc3p_1
+ -> Seq Scan on mc3p1 mc3p_2
Filter: ((a = 1) AND (abs(b) = 1))
- -> Seq Scan on mc3p_default mc3p_2
+ -> Seq Scan on mc3p_default mc3p_3
Filter: ((a = 1) AND (abs(b) = 1))
(7 rows)
QUERY PLAN
--------------------------------------------------------
Append
- -> Seq Scan on mc3p0 mc3p
+ -> Seq Scan on mc3p0 mc3p_1
Filter: ((c < 8) AND (a = 1) AND (abs(b) = 1))
- -> Seq Scan on mc3p1 mc3p_1
+ -> Seq Scan on mc3p1 mc3p_2
Filter: ((c < 8) AND (a = 1) AND (abs(b) = 1))
(5 rows)
QUERY PLAN
-----------------------------------------------------------------
Append
- -> Seq Scan on mc3p1 mc3p
+ -> Seq Scan on mc3p1 mc3p_1
Filter: ((a = 10) AND (abs(b) >= 5) AND (abs(b) <= 35))
- -> Seq Scan on mc3p2 mc3p_1
+ -> Seq Scan on mc3p2 mc3p_2
Filter: ((a = 10) AND (abs(b) >= 5) AND (abs(b) <= 35))
- -> Seq Scan on mc3p3 mc3p_2
+ -> Seq Scan on mc3p3 mc3p_3
Filter: ((a = 10) AND (abs(b) >= 5) AND (abs(b) <= 35))
- -> Seq Scan on mc3p4 mc3p_3
+ -> Seq Scan on mc3p4 mc3p_4
Filter: ((a = 10) AND (abs(b) >= 5) AND (abs(b) <= 35))
- -> Seq Scan on mc3p_default mc3p_4
+ -> Seq Scan on mc3p_default mc3p_5
Filter: ((a = 10) AND (abs(b) >= 5) AND (abs(b) <= 35))
(11 rows)
QUERY PLAN
---------------------------------------
Append
- -> Seq Scan on mc3p5 mc3p
+ -> Seq Scan on mc3p5 mc3p_1
Filter: (a > 10)
- -> Seq Scan on mc3p6 mc3p_1
+ -> Seq Scan on mc3p6 mc3p_2
Filter: (a > 10)
- -> Seq Scan on mc3p7 mc3p_2
+ -> Seq Scan on mc3p7 mc3p_3
Filter: (a > 10)
- -> Seq Scan on mc3p_default mc3p_3
+ -> Seq Scan on mc3p_default mc3p_4
Filter: (a > 10)
(9 rows)
QUERY PLAN
---------------------------------------
Append
- -> Seq Scan on mc3p1 mc3p
+ -> Seq Scan on mc3p1 mc3p_1
Filter: (a >= 10)
- -> Seq Scan on mc3p2 mc3p_1
+ -> Seq Scan on mc3p2 mc3p_2
Filter: (a >= 10)
- -> Seq Scan on mc3p3 mc3p_2
+ -> Seq Scan on mc3p3 mc3p_3
Filter: (a >= 10)
- -> Seq Scan on mc3p4 mc3p_3
+ -> Seq Scan on mc3p4 mc3p_4
Filter: (a >= 10)
- -> Seq Scan on mc3p5 mc3p_4
+ -> Seq Scan on mc3p5 mc3p_5
Filter: (a >= 10)
- -> Seq Scan on mc3p6 mc3p_5
+ -> Seq Scan on mc3p6 mc3p_6
Filter: (a >= 10)
- -> Seq Scan on mc3p7 mc3p_6
+ -> Seq Scan on mc3p7 mc3p_7
Filter: (a >= 10)
- -> Seq Scan on mc3p_default mc3p_7
+ -> Seq Scan on mc3p_default mc3p_8
Filter: (a >= 10)
(17 rows)
QUERY PLAN
---------------------------------------
Append
- -> Seq Scan on mc3p0 mc3p
+ -> Seq Scan on mc3p0 mc3p_1
Filter: (a < 10)
- -> Seq Scan on mc3p1 mc3p_1
+ -> Seq Scan on mc3p1 mc3p_2
Filter: (a < 10)
- -> Seq Scan on mc3p_default mc3p_2
+ -> Seq Scan on mc3p_default mc3p_3
Filter: (a < 10)
(7 rows)
QUERY PLAN
-----------------------------------------------
Append
- -> Seq Scan on mc3p0 mc3p
+ -> Seq Scan on mc3p0 mc3p_1
Filter: ((a <= 10) AND (abs(b) < 10))
- -> Seq Scan on mc3p1 mc3p_1
+ -> Seq Scan on mc3p1 mc3p_2
Filter: ((a <= 10) AND (abs(b) < 10))
- -> Seq Scan on mc3p2 mc3p_2
+ -> Seq Scan on mc3p2 mc3p_3
Filter: ((a <= 10) AND (abs(b) < 10))
- -> Seq Scan on mc3p_default mc3p_3
+ -> Seq Scan on mc3p_default mc3p_4
Filter: ((a <= 10) AND (abs(b) < 10))
(9 rows)
QUERY PLAN
---------------------------------------
Append
- -> Seq Scan on mc3p7 mc3p
+ -> Seq Scan on mc3p7 mc3p_1
Filter: (a > 20)
- -> Seq Scan on mc3p_default mc3p_1
+ -> Seq Scan on mc3p_default mc3p_2
Filter: (a > 20)
(5 rows)
QUERY PLAN
---------------------------------------
Append
- -> Seq Scan on mc3p5 mc3p
+ -> Seq Scan on mc3p5 mc3p_1
Filter: (a >= 20)
- -> Seq Scan on mc3p6 mc3p_1
+ -> Seq Scan on mc3p6 mc3p_2
Filter: (a >= 20)
- -> Seq Scan on mc3p7 mc3p_2
+ -> Seq Scan on mc3p7 mc3p_3
Filter: (a >= 20)
- -> Seq Scan on mc3p_default mc3p_3
+ -> Seq Scan on mc3p_default mc3p_4
Filter: (a >= 20)
(9 rows)
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------
Append
- -> Seq Scan on mc3p1 mc3p
+ -> Seq Scan on mc3p1 mc3p_1
Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)))
- -> Seq Scan on mc3p2 mc3p_1
+ -> Seq Scan on mc3p2 mc3p_2
Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)))
- -> Seq Scan on mc3p5 mc3p_2
+ -> Seq Scan on mc3p5 mc3p_3
Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)))
- -> Seq Scan on mc3p_default mc3p_3
+ -> Seq Scan on mc3p_default mc3p_4
Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)))
(9 rows)
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------
Append
- -> Seq Scan on mc3p0 mc3p
+ -> Seq Scan on mc3p0 mc3p_1
Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1))
- -> Seq Scan on mc3p1 mc3p_1
+ -> Seq Scan on mc3p1 mc3p_2
Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1))
- -> Seq Scan on mc3p2 mc3p_2
+ -> Seq Scan on mc3p2 mc3p_3
Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1))
- -> Seq Scan on mc3p5 mc3p_3
+ -> Seq Scan on mc3p5 mc3p_4
Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1))
- -> Seq Scan on mc3p_default mc3p_4
+ -> Seq Scan on mc3p_default mc3p_5
Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1))
(11 rows)
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------
Append
- -> Seq Scan on mc3p0 mc3p
+ -> Seq Scan on mc3p0 mc3p_1
Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1) OR (a = 1))
- -> Seq Scan on mc3p1 mc3p_1
+ -> Seq Scan on mc3p1 mc3p_2
Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1) OR (a = 1))
- -> Seq Scan on mc3p2 mc3p_2
+ -> Seq Scan on mc3p2 mc3p_3
Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1) OR (a = 1))
- -> Seq Scan on mc3p5 mc3p_3
+ -> Seq Scan on mc3p5 mc3p_4
Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1) OR (a = 1))
- -> Seq Scan on mc3p_default mc3p_4
+ -> Seq Scan on mc3p_default mc3p_5
Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1) OR (a = 1))
(11 rows)
QUERY PLAN
------------------------------------------------------
Append
- -> Seq Scan on mc3p0 mc3p
+ -> Seq Scan on mc3p0 mc3p_1
Filter: ((a = 1) OR (abs(b) = 1) OR (c = 1))
- -> Seq Scan on mc3p1 mc3p_1
+ -> Seq Scan on mc3p1 mc3p_2
Filter: ((a = 1) OR (abs(b) = 1) OR (c = 1))
- -> Seq Scan on mc3p2 mc3p_2
+ -> Seq Scan on mc3p2 mc3p_3
Filter: ((a = 1) OR (abs(b) = 1) OR (c = 1))
- -> Seq Scan on mc3p3 mc3p_3
+ -> Seq Scan on mc3p3 mc3p_4
Filter: ((a = 1) OR (abs(b) = 1) OR (c = 1))
- -> Seq Scan on mc3p4 mc3p_4
+ -> Seq Scan on mc3p4 mc3p_5
Filter: ((a = 1) OR (abs(b) = 1) OR (c = 1))
- -> Seq Scan on mc3p5 mc3p_5
+ -> Seq Scan on mc3p5 mc3p_6
Filter: ((a = 1) OR (abs(b) = 1) OR (c = 1))
- -> Seq Scan on mc3p6 mc3p_6
+ -> Seq Scan on mc3p6 mc3p_7
Filter: ((a = 1) OR (abs(b) = 1) OR (c = 1))
- -> Seq Scan on mc3p7 mc3p_7
+ -> Seq Scan on mc3p7 mc3p_8
Filter: ((a = 1) OR (abs(b) = 1) OR (c = 1))
- -> Seq Scan on mc3p_default mc3p_8
+ -> Seq Scan on mc3p_default mc3p_9
Filter: ((a = 1) OR (abs(b) = 1) OR (c = 1))
(19 rows)
QUERY PLAN
------------------------------------------------------------------------------
Append
- -> Seq Scan on mc3p0 mc3p
+ -> Seq Scan on mc3p0 mc3p_1
Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 10)))
- -> Seq Scan on mc3p1 mc3p_1
+ -> Seq Scan on mc3p1 mc3p_2
Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 10)))
- -> Seq Scan on mc3p2 mc3p_2
+ -> Seq Scan on mc3p2 mc3p_3
Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 10)))
- -> Seq Scan on mc3p3 mc3p_3
+ -> Seq Scan on mc3p3 mc3p_4
Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 10)))
- -> Seq Scan on mc3p4 mc3p_4
+ -> Seq Scan on mc3p4 mc3p_5
Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 10)))
- -> Seq Scan on mc3p_default mc3p_5
+ -> Seq Scan on mc3p_default mc3p_6
Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 10)))
(13 rows)
QUERY PLAN
-----------------------------------------------------------------------------
Append
- -> Seq Scan on mc3p0 mc3p
+ -> Seq Scan on mc3p0 mc3p_1
Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 9)))
- -> Seq Scan on mc3p1 mc3p_1
+ -> Seq Scan on mc3p1 mc3p_2
Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 9)))
- -> Seq Scan on mc3p2 mc3p_2
+ -> Seq Scan on mc3p2 mc3p_3
Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 9)))
- -> Seq Scan on mc3p_default mc3p_3
+ -> Seq Scan on mc3p_default mc3p_4
Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 9)))
(9 rows)
QUERY PLAN
---------------------------------------
Append
- -> Seq Scan on mc2p0 mc2p
+ -> Seq Scan on mc2p0 mc2p_1
Filter: (a < 2)
- -> Seq Scan on mc2p1 mc2p_1
+ -> Seq Scan on mc2p1 mc2p_2
Filter: (a < 2)
- -> Seq Scan on mc2p2 mc2p_2
+ -> Seq Scan on mc2p2 mc2p_3
Filter: (a < 2)
- -> Seq Scan on mc2p_default mc2p_3
+ -> Seq Scan on mc2p_default mc2p_4
Filter: (a < 2)
(9 rows)
QUERY PLAN
---------------------------------------
Append
- -> Seq Scan on mc2p2 mc2p
+ -> Seq Scan on mc2p2 mc2p_1
Filter: (a > 1)
- -> Seq Scan on mc2p3 mc2p_1
+ -> Seq Scan on mc2p3 mc2p_2
Filter: (a > 1)
- -> Seq Scan on mc2p4 mc2p_2
+ -> Seq Scan on mc2p4 mc2p_3
Filter: (a > 1)
- -> Seq Scan on mc2p5 mc2p_3
+ -> Seq Scan on mc2p5 mc2p_4
Filter: (a > 1)
- -> Seq Scan on mc2p_default mc2p_4
+ -> Seq Scan on mc2p_default mc2p_5
Filter: (a > 1)
(11 rows)
QUERY PLAN
------------------------------------------------
Append
- -> Seq Scan on boolpart_f boolpart
+ -> Seq Scan on boolpart_f boolpart_1
Filter: (a = ANY ('{t,f}'::boolean[]))
- -> Seq Scan on boolpart_t boolpart_1
+ -> Seq Scan on boolpart_t boolpart_2
Filter: (a = ANY ('{t,f}'::boolean[]))
(5 rows)
QUERY PLAN
--------------------------------------------------
Append
- -> Seq Scan on boolpart_f boolpart
+ -> Seq Scan on boolpart_f boolpart_1
Filter: ((a IS TRUE) OR (a IS NOT TRUE))
- -> Seq Scan on boolpart_t boolpart_1
+ -> Seq Scan on boolpart_t boolpart_2
Filter: ((a IS TRUE) OR (a IS NOT TRUE))
(5 rows)
QUERY PLAN
-----------------------------------------------
Append
- -> Seq Scan on boolpart_f boolpart
+ -> Seq Scan on boolpart_f boolpart_1
Filter: (a IS UNKNOWN)
- -> Seq Scan on boolpart_t boolpart_1
+ -> Seq Scan on boolpart_t boolpart_2
Filter: (a IS UNKNOWN)
- -> Seq Scan on boolpart_default boolpart_2
+ -> Seq Scan on boolpart_default boolpart_3
Filter: (a IS UNKNOWN)
(7 rows)
QUERY PLAN
-----------------------------------------------
Append
- -> Seq Scan on boolpart_f boolpart
+ -> Seq Scan on boolpart_f boolpart_1
Filter: (a IS NOT UNKNOWN)
- -> Seq Scan on boolpart_t boolpart_1
+ -> Seq Scan on boolpart_t boolpart_2
Filter: (a IS NOT UNKNOWN)
- -> Seq Scan on boolpart_default boolpart_2
+ -> Seq Scan on boolpart_default boolpart_3
Filter: (a IS NOT UNKNOWN)
(7 rows)
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------
Append
- -> Seq Scan on coercepart_ab coercepart
+ -> Seq Scan on coercepart_ab coercepart_1
Filter: ((a)::text = ANY ((ARRAY['ab'::character varying, (to_char(125, '999'::text))::character varying])::text[]))
- -> Seq Scan on coercepart_bc coercepart_1
+ -> Seq Scan on coercepart_bc coercepart_2
Filter: ((a)::text = ANY ((ARRAY['ab'::character varying, (to_char(125, '999'::text))::character varying])::text[]))
- -> Seq Scan on coercepart_cd coercepart_2
+ -> Seq Scan on coercepart_cd coercepart_3
Filter: ((a)::text = ANY ((ARRAY['ab'::character varying, (to_char(125, '999'::text))::character varying])::text[]))
(7 rows)
QUERY PLAN
----------------------------------------------------
Append
- -> Seq Scan on coercepart_ab coercepart
+ -> Seq Scan on coercepart_ab coercepart_1
Filter: ((a)::text ~ ANY ('{ab}'::text[]))
- -> Seq Scan on coercepart_bc coercepart_1
+ -> Seq Scan on coercepart_bc coercepart_2
Filter: ((a)::text ~ ANY ('{ab}'::text[]))
- -> Seq Scan on coercepart_cd coercepart_2
+ -> Seq Scan on coercepart_cd coercepart_3
Filter: ((a)::text ~ ANY ('{ab}'::text[]))
(7 rows)
QUERY PLAN
-----------------------------------------------------
Append
- -> Seq Scan on coercepart_ab coercepart
+ -> Seq Scan on coercepart_ab coercepart_1
Filter: ((a)::text !~ ALL ('{ab}'::text[]))
- -> Seq Scan on coercepart_bc coercepart_1
+ -> Seq Scan on coercepart_bc coercepart_2
Filter: ((a)::text !~ ALL ('{ab}'::text[]))
- -> Seq Scan on coercepart_cd coercepart_2
+ -> Seq Scan on coercepart_cd coercepart_3
Filter: ((a)::text !~ ALL ('{ab}'::text[]))
(7 rows)
QUERY PLAN
-------------------------------------------------------
Append
- -> Seq Scan on coercepart_ab coercepart
+ -> Seq Scan on coercepart_ab coercepart_1
Filter: ((a)::text ~ ANY ('{ab,bc}'::text[]))
- -> Seq Scan on coercepart_bc coercepart_1
+ -> Seq Scan on coercepart_bc coercepart_2
Filter: ((a)::text ~ ANY ('{ab,bc}'::text[]))
- -> Seq Scan on coercepart_cd coercepart_2
+ -> Seq Scan on coercepart_cd coercepart_3
Filter: ((a)::text ~ ANY ('{ab,bc}'::text[]))
(7 rows)
QUERY PLAN
--------------------------------------------------------
Append
- -> Seq Scan on coercepart_ab coercepart
+ -> Seq Scan on coercepart_ab coercepart_1
Filter: ((a)::text !~ ALL ('{ab,bc}'::text[]))
- -> Seq Scan on coercepart_bc coercepart_1
+ -> Seq Scan on coercepart_bc coercepart_2
Filter: ((a)::text !~ ALL ('{ab,bc}'::text[]))
- -> Seq Scan on coercepart_cd coercepart_2
+ -> Seq Scan on coercepart_cd coercepart_3
Filter: ((a)::text !~ ALL ('{ab,bc}'::text[]))
(7 rows)
QUERY PLAN
-------------------------------------------------------
Append
- -> Seq Scan on coercepart_ab coercepart
+ -> Seq Scan on coercepart_ab coercepart_1
Filter: ((a)::text = ANY ('{ab,bc}'::text[]))
- -> Seq Scan on coercepart_bc coercepart_1
+ -> Seq Scan on coercepart_bc coercepart_2
Filter: ((a)::text = ANY ('{ab,bc}'::text[]))
(5 rows)
Output: p.x, p.b
Sort Key: p.x
-> Append
- -> Seq Scan on public.part_p1 p
- Output: p.x, p.b
- -> Seq Scan on public.part_rev p_1
+ -> Seq Scan on public.part_p1 p_1
Output: p_1.x, p_1.b
- -> Seq Scan on public.part_p2_p1 p_2
+ -> Seq Scan on public.part_rev p_2
Output: p_2.x, p_2.b
+ -> Seq Scan on public.part_p2_p1 p_3
+ Output: p_3.x, p_3.b
(10 rows)
--
-----------------------------------------------------------------------
Nested Loop
-> Append
- -> Seq Scan on mc2p1 t1
+ -> Seq Scan on mc2p1 t1_1
Filter: (a = 1)
- -> Seq Scan on mc2p2 t1_1
+ -> Seq Scan on mc2p2 t1_2
Filter: (a = 1)
- -> Seq Scan on mc2p_default t1_2
+ -> Seq Scan on mc2p_default t1_3
Filter: (a = 1)
-> Aggregate
-> Append
- -> Seq Scan on mc3p0 t2
+ -> Seq Scan on mc3p0 t2_1
Filter: ((a = t1.b) AND (c = 1) AND (abs(b) = 1))
- -> Seq Scan on mc3p1 t2_1
+ -> Seq Scan on mc3p1 t2_2
Filter: ((a = t1.b) AND (c = 1) AND (abs(b) = 1))
- -> Seq Scan on mc3p2 t2_2
+ -> Seq Scan on mc3p2 t2_3
Filter: ((a = t1.b) AND (c = 1) AND (abs(b) = 1))
- -> Seq Scan on mc3p3 t2_3
+ -> Seq Scan on mc3p3 t2_4
Filter: ((a = t1.b) AND (c = 1) AND (abs(b) = 1))
- -> Seq Scan on mc3p4 t2_4
+ -> Seq Scan on mc3p4 t2_5
Filter: ((a = t1.b) AND (c = 1) AND (abs(b) = 1))
- -> Seq Scan on mc3p5 t2_5
+ -> Seq Scan on mc3p5 t2_6
Filter: ((a = t1.b) AND (c = 1) AND (abs(b) = 1))
- -> Seq Scan on mc3p6 t2_6
+ -> Seq Scan on mc3p6 t2_7
Filter: ((a = t1.b) AND (c = 1) AND (abs(b) = 1))
- -> Seq Scan on mc3p7 t2_7
+ -> Seq Scan on mc3p7 t2_8
Filter: ((a = t1.b) AND (c = 1) AND (abs(b) = 1))
- -> Seq Scan on mc3p_default t2_8
+ -> Seq Scan on mc3p_default t2_9
Filter: ((a = t1.b) AND (c = 1) AND (abs(b) = 1))
(28 rows)
-----------------------------------------------------------------------
Nested Loop
-> Append
- -> Seq Scan on mc2p1 t1
+ -> Seq Scan on mc2p1 t1_1
Filter: (a = 1)
- -> Seq Scan on mc2p2 t1_1
+ -> Seq Scan on mc2p2 t1_2
Filter: (a = 1)
- -> Seq Scan on mc2p_default t1_2
+ -> Seq Scan on mc2p_default t1_3
Filter: (a = 1)
-> Aggregate
-> Append
- -> Seq Scan on mc3p0 t2
+ -> Seq Scan on mc3p0 t2_1
Filter: ((c = t1.b) AND (a = 1) AND (abs(b) = 1))
- -> Seq Scan on mc3p1 t2_1
+ -> Seq Scan on mc3p1 t2_2
Filter: ((c = t1.b) AND (a = 1) AND (abs(b) = 1))
- -> Seq Scan on mc3p_default t2_2
+ -> Seq Scan on mc3p_default t2_3
Filter: ((c = t1.b) AND (a = 1) AND (abs(b) = 1))
(16 rows)
-> Seq Scan on mc3p1 t2
Filter: ((a = 1) AND (c = 1) AND (abs(b) = 1))
-> Append
- -> Seq Scan on mc2p1 t1
+ -> Seq Scan on mc2p1 t1_1
Filter: (a = 1)
- -> Seq Scan on mc2p2 t1_1
+ -> Seq Scan on mc2p2 t1_2
Filter: (a = 1)
- -> Seq Scan on mc2p_default t1_2
+ -> Seq Scan on mc2p_default t1_3
Filter: (a = 1)
(11 rows)
QUERY PLAN
----------------------------
Append
- -> Seq Scan on rp0 rp
+ -> Seq Scan on rp0 rp_1
Filter: (a <> 1)
- -> Seq Scan on rp1 rp_1
+ -> Seq Scan on rp1 rp_2
Filter: (a <> 1)
- -> Seq Scan on rp2 rp_2
+ -> Seq Scan on rp2 rp_3
Filter: (a <> 1)
(7 rows)
QUERY PLAN
-----------------------------------------
Append
- -> Seq Scan on rp0 rp
+ -> Seq Scan on rp0 rp_1
Filter: ((a <> 1) AND (a <> 2))
- -> Seq Scan on rp1 rp_1
+ -> Seq Scan on rp1 rp_2
Filter: ((a <> 1) AND (a <> 2))
- -> Seq Scan on rp2 rp_2
+ -> Seq Scan on rp2 rp_3
Filter: ((a <> 1) AND (a <> 2))
(7 rows)
QUERY PLAN
------------------------------------
Append
- -> Seq Scan on lp_ad lp
+ -> Seq Scan on lp_ad lp_1
Filter: (a <> 'a'::bpchar)
- -> Seq Scan on lp_bc lp_1
+ -> Seq Scan on lp_bc lp_2
Filter: (a <> 'a'::bpchar)
- -> Seq Scan on lp_ef lp_2
+ -> Seq Scan on lp_ef lp_3
Filter: (a <> 'a'::bpchar)
- -> Seq Scan on lp_g lp_3
+ -> Seq Scan on lp_g lp_4
Filter: (a <> 'a'::bpchar)
- -> Seq Scan on lp_default lp_4
+ -> Seq Scan on lp_default lp_5
Filter: (a <> 'a'::bpchar)
(11 rows)
QUERY PLAN
------------------------------------------------------------------------------
Append
- -> Seq Scan on lp_bc lp
+ -> Seq Scan on lp_bc lp_1
Filter: (((a <> 'a'::bpchar) AND (a <> 'd'::bpchar)) OR (a IS NULL))
- -> Seq Scan on lp_ef lp_1
+ -> Seq Scan on lp_ef lp_2
Filter: (((a <> 'a'::bpchar) AND (a <> 'd'::bpchar)) OR (a IS NULL))
- -> Seq Scan on lp_g lp_2
+ -> Seq Scan on lp_g lp_3
Filter: (((a <> 'a'::bpchar) AND (a <> 'd'::bpchar)) OR (a IS NULL))
- -> Seq Scan on lp_null lp_3
+ -> Seq Scan on lp_null lp_4
Filter: (((a <> 'a'::bpchar) AND (a <> 'd'::bpchar)) OR (a IS NULL))
- -> Seq Scan on lp_default lp_4
+ -> Seq Scan on lp_default lp_5
Filter: (((a <> 'a'::bpchar) AND (a <> 'd'::bpchar)) OR (a IS NULL))
(11 rows)
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------
Append
- -> Seq Scan on rlp3efgh rlp
+ -> Seq Scan on rlp3efgh rlp_1
Filter: ((b IS NOT NULL) AND ((b)::text <> 'ab'::text) AND ((b)::text <> 'cd'::text) AND ((b)::text <> 'xy'::text) AND (a = 15))
- -> Seq Scan on rlp3_default rlp_1
+ -> Seq Scan on rlp3_default rlp_2
Filter: ((b IS NOT NULL) AND ((b)::text <> 'ab'::text) AND ((b)::text <> 'cd'::text) AND ((b)::text <> 'xy'::text) AND (a = 15))
(5 rows)
QUERY PLAN
------------------------------------------------------------
Append
- -> Seq Scan on coll_pruning_multi1 coll_pruning_multi
+ -> Seq Scan on coll_pruning_multi1 coll_pruning_multi_1
Filter: (substr(a, 1) = 'e'::text COLLATE "C")
- -> Seq Scan on coll_pruning_multi2 coll_pruning_multi_1
+ -> Seq Scan on coll_pruning_multi2 coll_pruning_multi_2
Filter: (substr(a, 1) = 'e'::text COLLATE "C")
- -> Seq Scan on coll_pruning_multi3 coll_pruning_multi_2
+ -> Seq Scan on coll_pruning_multi3 coll_pruning_multi_3
Filter: (substr(a, 1) = 'e'::text COLLATE "C")
(7 rows)
QUERY PLAN
------------------------------------------------------------
Append
- -> Seq Scan on coll_pruning_multi1 coll_pruning_multi
+ -> Seq Scan on coll_pruning_multi1 coll_pruning_multi_1
Filter: (substr(a, 1) = 'a'::text COLLATE "POSIX")
- -> Seq Scan on coll_pruning_multi2 coll_pruning_multi_1
+ -> Seq Scan on coll_pruning_multi2 coll_pruning_multi_2
Filter: (substr(a, 1) = 'a'::text COLLATE "POSIX")
(5 rows)
QUERY PLAN
------------------------------------------------------
Append
- -> Seq Scan on like_op_noprune1 like_op_noprune
+ -> Seq Scan on like_op_noprune1 like_op_noprune_1
Filter: (a ~~ '%BC'::text)
- -> Seq Scan on like_op_noprune2 like_op_noprune_1
+ -> Seq Scan on like_op_noprune2 like_op_noprune_2
Filter: (a ~~ '%BC'::text)
(5 rows)
QUERY PLAN
----------------------------
Append
- -> Seq Scan on hp0 hp
+ -> Seq Scan on hp0 hp_1
Filter: (a = 1)
- -> Seq Scan on hp1 hp_1
+ -> Seq Scan on hp1 hp_2
Filter: (a = 1)
- -> Seq Scan on hp2 hp_2
+ -> Seq Scan on hp2 hp_3
Filter: (a = 1)
- -> Seq Scan on hp3 hp_3
+ -> Seq Scan on hp3 hp_4
Filter: (a = 1)
(9 rows)
QUERY PLAN
-----------------------------------
Append
- -> Seq Scan on hp0 hp
+ -> Seq Scan on hp0 hp_1
Filter: (b = 'xxx'::text)
- -> Seq Scan on hp1 hp_1
+ -> Seq Scan on hp1 hp_2
Filter: (b = 'xxx'::text)
- -> Seq Scan on hp2 hp_2
+ -> Seq Scan on hp2 hp_3
Filter: (b = 'xxx'::text)
- -> Seq Scan on hp3 hp_3
+ -> Seq Scan on hp3 hp_4
Filter: (b = 'xxx'::text)
(9 rows)
QUERY PLAN
-----------------------------
Append
- -> Seq Scan on hp0 hp
+ -> Seq Scan on hp0 hp_1
Filter: (a IS NULL)
- -> Seq Scan on hp1 hp_1
+ -> Seq Scan on hp1 hp_2
Filter: (a IS NULL)
- -> Seq Scan on hp2 hp_2
+ -> Seq Scan on hp2 hp_3
Filter: (a IS NULL)
- -> Seq Scan on hp3 hp_3
+ -> Seq Scan on hp3 hp_4
Filter: (a IS NULL)
(9 rows)
QUERY PLAN
-----------------------------
Append
- -> Seq Scan on hp0 hp
+ -> Seq Scan on hp0 hp_1
Filter: (b IS NULL)
- -> Seq Scan on hp1 hp_1
+ -> Seq Scan on hp1 hp_2
Filter: (b IS NULL)
- -> Seq Scan on hp2 hp_2
+ -> Seq Scan on hp2 hp_3
Filter: (b IS NULL)
- -> Seq Scan on hp3 hp_3
+ -> Seq Scan on hp3 hp_4
Filter: (b IS NULL)
(9 rows)
QUERY PLAN
-------------------------------------------------
Append
- -> Seq Scan on hp0 hp
+ -> Seq Scan on hp0 hp_1
Filter: ((a < 1) AND (b = 'xxx'::text))
- -> Seq Scan on hp1 hp_1
+ -> Seq Scan on hp1 hp_2
Filter: ((a < 1) AND (b = 'xxx'::text))
- -> Seq Scan on hp2 hp_2
+ -> Seq Scan on hp2 hp_3
Filter: ((a < 1) AND (b = 'xxx'::text))
- -> Seq Scan on hp3 hp_3
+ -> Seq Scan on hp3 hp_4
Filter: ((a < 1) AND (b = 'xxx'::text))
(9 rows)
QUERY PLAN
--------------------------------------------------
Append
- -> Seq Scan on hp0 hp
+ -> Seq Scan on hp0 hp_1
Filter: ((a <> 1) AND (b = 'yyy'::text))
- -> Seq Scan on hp1 hp_1
+ -> Seq Scan on hp1 hp_2
Filter: ((a <> 1) AND (b = 'yyy'::text))
- -> Seq Scan on hp2 hp_2
+ -> Seq Scan on hp2 hp_3
Filter: ((a <> 1) AND (b = 'yyy'::text))
- -> Seq Scan on hp3 hp_3
+ -> Seq Scan on hp3 hp_4
Filter: ((a <> 1) AND (b = 'yyy'::text))
(9 rows)
QUERY PLAN
---------------------------------------------------
Append
- -> Seq Scan on hp0 hp
+ -> Seq Scan on hp0 hp_1
Filter: ((a <> 1) AND (b <> 'xxx'::text))
- -> Seq Scan on hp1 hp_1
+ -> Seq Scan on hp1 hp_2
Filter: ((a <> 1) AND (b <> 'xxx'::text))
- -> Seq Scan on hp2 hp_2
+ -> Seq Scan on hp2 hp_3
Filter: ((a <> 1) AND (b <> 'xxx'::text))
- -> Seq Scan on hp3 hp_3
+ -> Seq Scan on hp3 hp_4
Filter: ((a <> 1) AND (b <> 'xxx'::text))
(9 rows)
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------
Append
- -> Seq Scan on hp0 hp
+ -> Seq Scan on hp0 hp_1
Filter: (((a = 1) AND (b = 'abcde'::text)) OR ((a = 2) AND (b = 'xxx'::text)) OR ((a IS NULL) AND (b IS NULL)))
- -> Seq Scan on hp2 hp_1
+ -> Seq Scan on hp2 hp_2
Filter: (((a = 1) AND (b = 'abcde'::text)) OR ((a = 2) AND (b = 'xxx'::text)) OR ((a IS NULL) AND (b IS NULL)))
- -> Seq Scan on hp3 hp_2
+ -> Seq Scan on hp3 hp_3
Filter: (((a = 1) AND (b = 'abcde'::text)) OR ((a = 2) AND (b = 'xxx'::text)) OR ((a IS NULL) AND (b IS NULL)))
(7 rows)
---------------------------------------------------------
Append (actual rows=0 loops=1)
Subplans Removed: 6
- -> Seq Scan on ab_a2_b1 ab (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_1 (actual rows=0 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
- -> Seq Scan on ab_a2_b2 ab_1 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b2 ab_2 (actual rows=0 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
- -> Seq Scan on ab_a2_b3 ab_2 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b3 ab_3 (actual rows=0 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
(8 rows)
---------------------------------------------------------
Append (actual rows=0 loops=1)
Subplans Removed: 3
- -> Seq Scan on ab_a1_b1 ab (actual rows=0 loops=1)
+ -> Seq Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
- -> Seq Scan on ab_a1_b2 ab_1 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a1_b2 ab_2 (actual rows=0 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
- -> Seq Scan on ab_a1_b3 ab_2 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a1_b3 ab_3 (actual rows=0 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
- -> Seq Scan on ab_a2_b1 ab_3 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_4 (actual rows=0 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
- -> Seq Scan on ab_a2_b2 ab_4 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b2 ab_5 (actual rows=0 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
- -> Seq Scan on ab_a2_b3 ab_5 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b3 ab_6 (actual rows=0 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b <= $3))
(14 rows)
---------------------------------------------------------
Append (actual rows=0 loops=1)
Subplans Removed: 4
- -> Seq Scan on ab_a2_b1 ab (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_1 (actual rows=0 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
- -> Seq Scan on ab_a2_b2 ab_1 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b2 ab_2 (actual rows=0 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
(6 rows)
---------------------------------------------------------
Append (actual rows=0 loops=1)
Subplans Removed: 2
- -> Seq Scan on ab_a2_b1 ab (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_1 (actual rows=0 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
- -> Seq Scan on ab_a2_b2 ab_1 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b2 ab_2 (actual rows=0 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
- -> Seq Scan on ab_a3_b1 ab_2 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a3_b1 ab_3 (actual rows=0 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
- -> Seq Scan on ab_a3_b2 ab_3 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a3_b2 ab_4 (actual rows=0 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
(10 rows)
InitPlan 1 (returns $0)
-> Result (actual rows=1 loops=1)
Subplans Removed: 6
- -> Seq Scan on ab_a2_b1 ab (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_1 (actual rows=0 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b < $0))
- -> Seq Scan on ab_a2_b2 ab_1 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b2 ab_2 (actual rows=0 loops=1)
Filter: ((a >= $1) AND (a <= $2) AND (b < $0))
- -> Seq Scan on ab_a2_b3 ab_2 (never executed)
+ -> Seq Scan on ab_a2_b3 ab_3 (never executed)
Filter: ((a >= $1) AND (a <= $2) AND (b < $0))
(10 rows)
InitPlan 1 (returns $0)
-> Result (actual rows=1 loops=1)
Subplans Removed: 6
- -> Seq Scan on ab_a1_b2 ab (actual rows=0 loops=1)
+ -> Seq Scan on ab_a1_b2 ab_1 (actual rows=0 loops=1)
Filter: ((b >= $1) AND (b <= $2) AND (a < $0))
- -> Seq Scan on ab_a2_b2 ab_1 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b2 ab_2 (actual rows=0 loops=1)
Filter: ((b >= $1) AND (b <= $2) AND (a < $0))
- -> Seq Scan on ab_a3_b2 ab_2 (never executed)
+ -> Seq Scan on ab_a3_b2 ab_3 (never executed)
Filter: ((b >= $1) AND (b <= $2) AND (a < $0))
(10 rows)
create function list_part_fn(int) returns int as $$ begin return $1; end;$$ language plpgsql stable;
-- Ensure pruning works using a stable function containing no Vars
explain (analyze, costs off, summary off, timing off) select * from list_part where a = list_part_fn(1);
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------
Append (actual rows=1 loops=1)
Subplans Removed: 3
- -> Seq Scan on list_part1 list_part (actual rows=1 loops=1)
+ -> Seq Scan on list_part1 list_part_1 (actual rows=1 loops=1)
Filter: (a = list_part_fn(1))
(4 rows)
QUERY PLAN
------------------------------------------------------------------
Append (actual rows=4 loops=1)
- -> Seq Scan on list_part1 list_part (actual rows=1 loops=1)
+ -> Seq Scan on list_part1 list_part_1 (actual rows=1 loops=1)
Filter: (a = list_part_fn(a))
- -> Seq Scan on list_part2 list_part_1 (actual rows=1 loops=1)
+ -> Seq Scan on list_part2 list_part_2 (actual rows=1 loops=1)
Filter: (a = list_part_fn(a))
- -> Seq Scan on list_part3 list_part_2 (actual rows=1 loops=1)
+ -> Seq Scan on list_part3 list_part_3 (actual rows=1 loops=1)
Filter: (a = list_part_fn(a))
- -> Seq Scan on list_part4 list_part_3 (actual rows=1 loops=1)
+ -> Seq Scan on list_part4 list_part_4 (actual rows=1 loops=1)
Filter: (a = list_part_fn(a))
(9 rows)
QUERY PLAN
------------------------------------------------------------------
Append (actual rows=0 loops=1)
- -> Seq Scan on list_part1 list_part (actual rows=0 loops=1)
+ -> Seq Scan on list_part1 list_part_1 (actual rows=0 loops=1)
Filter: (a = (list_part_fn(1) + a))
Rows Removed by Filter: 1
- -> Seq Scan on list_part2 list_part_1 (actual rows=0 loops=1)
+ -> Seq Scan on list_part2 list_part_2 (actual rows=0 loops=1)
Filter: (a = (list_part_fn(1) + a))
Rows Removed by Filter: 1
- -> Seq Scan on list_part3 list_part_2 (actual rows=0 loops=1)
+ -> Seq Scan on list_part3 list_part_3 (actual rows=0 loops=1)
Filter: (a = (list_part_fn(1) + a))
Rows Removed by Filter: 1
- -> Seq Scan on list_part4 list_part_3 (actual rows=0 loops=1)
+ -> Seq Scan on list_part4 list_part_4 (actual rows=0 loops=1)
Filter: (a = (list_part_fn(1) + a))
Rows Removed by Filter: 1
(13 rows)
-> Partial Aggregate (actual rows=N loops=N)
-> Parallel Append (actual rows=N loops=N)
Subplans Removed: 6
- -> Parallel Seq Scan on ab_a2_b1 ab (actual rows=N loops=N)
+ -> Parallel Seq Scan on ab_a2_b1 ab_1 (actual rows=N loops=N)
Filter: ((a >= $1) AND (a <= $2) AND (b < 4))
- -> Parallel Seq Scan on ab_a2_b2 ab_1 (actual rows=N loops=N)
+ -> Parallel Seq Scan on ab_a2_b2 ab_2 (actual rows=N loops=N)
Filter: ((a >= $1) AND (a <= $2) AND (b < 4))
- -> Parallel Seq Scan on ab_a2_b3 ab_2 (actual rows=N loops=N)
+ -> Parallel Seq Scan on ab_a2_b3 ab_3 (actual rows=N loops=N)
Filter: ((a >= $1) AND (a <= $2) AND (b < 4))
(13 rows)
-> Partial Aggregate (actual rows=N loops=N)
-> Parallel Append (actual rows=N loops=N)
Subplans Removed: 6
- -> Parallel Seq Scan on ab_a1_b1 ab (actual rows=N loops=N)
+ -> Parallel Seq Scan on ab_a1_b1 ab_1 (actual rows=N loops=N)
Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
- -> Parallel Seq Scan on ab_a1_b2 ab_1 (actual rows=N loops=N)
+ -> Parallel Seq Scan on ab_a1_b2 ab_2 (actual rows=N loops=N)
Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
- -> Parallel Seq Scan on ab_a1_b3 ab_2 (actual rows=N loops=N)
+ -> Parallel Seq Scan on ab_a1_b3 ab_3 (actual rows=N loops=N)
Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
(13 rows)
-> Partial Aggregate (actual rows=N loops=N)
-> Parallel Append (actual rows=N loops=N)
Subplans Removed: 3
- -> Parallel Seq Scan on ab_a2_b1 ab (actual rows=N loops=N)
+ -> Parallel Seq Scan on ab_a2_b1 ab_1 (actual rows=N loops=N)
Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
- -> Parallel Seq Scan on ab_a2_b2 ab_1 (actual rows=N loops=N)
+ -> Parallel Seq Scan on ab_a2_b2 ab_2 (actual rows=N loops=N)
Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
- -> Parallel Seq Scan on ab_a2_b3 ab_2 (actual rows=N loops=N)
+ -> Parallel Seq Scan on ab_a2_b3 ab_3 (actual rows=N loops=N)
Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
- -> Parallel Seq Scan on ab_a3_b1 ab_3 (actual rows=N loops=N)
+ -> Parallel Seq Scan on ab_a3_b1 ab_4 (actual rows=N loops=N)
Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
- -> Parallel Seq Scan on ab_a3_b2 ab_4 (actual rows=N loops=N)
+ -> Parallel Seq Scan on ab_a3_b2 ab_5 (actual rows=N loops=N)
Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
- -> Parallel Seq Scan on ab_a3_b3 ab_5 (actual rows=N loops=N)
+ -> Parallel Seq Scan on ab_a3_b3 ab_6 (actual rows=N loops=N)
Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
(19 rows)
-> Partial Aggregate (actual rows=N loops=N)
-> Parallel Append (actual rows=N loops=N)
Subplans Removed: 8
- -> Parallel Seq Scan on ab_a1_b1 ab (never executed)
+ -> Parallel Seq Scan on ab_a1_b1 ab_1 (never executed)
Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
(9 rows)
Params Evaluated: $0, $1
Workers Launched: N
-> Parallel Append (actual rows=N loops=N)
- -> Parallel Seq Scan on ab_a1_b2 ab (actual rows=N loops=N)
+ -> Parallel Seq Scan on ab_a1_b2 ab_1 (actual rows=N loops=N)
Filter: ((b = 2) AND ((a = $0) OR (a = $1)))
- -> Parallel Seq Scan on ab_a2_b2 ab_1 (never executed)
+ -> Parallel Seq Scan on ab_a2_b2 ab_2 (never executed)
Filter: ((b = 2) AND ((a = $0) OR (a = $1)))
- -> Parallel Seq Scan on ab_a3_b2 ab_2 (actual rows=N loops=N)
+ -> Parallel Seq Scan on ab_a3_b2 ab_3 (actual rows=N loops=N)
Filter: ((b = 2) AND ((a = $0) OR (a = $1)))
(16 rows)
-> Parallel Seq Scan on lprt_a a (actual rows=N loops=N)
Filter: (a = ANY ('{0,0,1}'::integer[]))
-> Append (actual rows=N loops=N)
- -> Index Scan using ab_a1_b1_a_idx on ab_a1_b1 ab (actual rows=N loops=N)
+ -> Index Scan using ab_a1_b1_a_idx on ab_a1_b1 ab_1 (actual rows=N loops=N)
Index Cond: (a = a.a)
- -> Index Scan using ab_a1_b2_a_idx on ab_a1_b2 ab_1 (actual rows=N loops=N)
+ -> Index Scan using ab_a1_b2_a_idx on ab_a1_b2 ab_2 (actual rows=N loops=N)
Index Cond: (a = a.a)
- -> Index Scan using ab_a1_b3_a_idx on ab_a1_b3 ab_2 (actual rows=N loops=N)
+ -> Index Scan using ab_a1_b3_a_idx on ab_a1_b3 ab_3 (actual rows=N loops=N)
Index Cond: (a = a.a)
- -> Index Scan using ab_a2_b1_a_idx on ab_a2_b1 ab_3 (never executed)
+ -> Index Scan using ab_a2_b1_a_idx on ab_a2_b1 ab_4 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a2_b2_a_idx on ab_a2_b2 ab_4 (never executed)
+ -> Index Scan using ab_a2_b2_a_idx on ab_a2_b2 ab_5 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a2_b3_a_idx on ab_a2_b3 ab_5 (never executed)
+ -> Index Scan using ab_a2_b3_a_idx on ab_a2_b3 ab_6 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a3_b1_a_idx on ab_a3_b1 ab_6 (never executed)
+ -> Index Scan using ab_a3_b1_a_idx on ab_a3_b1 ab_7 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a3_b2_a_idx on ab_a3_b2 ab_7 (never executed)
+ -> Index Scan using ab_a3_b2_a_idx on ab_a3_b2 ab_8 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a3_b3_a_idx on ab_a3_b3 ab_8 (never executed)
+ -> Index Scan using ab_a3_b3_a_idx on ab_a3_b3 ab_9 (never executed)
Index Cond: (a = a.a)
(27 rows)
-> Parallel Seq Scan on lprt_a a (actual rows=N loops=N)
Filter: (a = ANY ('{0,0,1}'::integer[]))
-> Append (actual rows=N loops=N)
- -> Index Scan using ab_a1_b1_a_idx on ab_a1_b1 ab (actual rows=N loops=N)
+ -> Index Scan using ab_a1_b1_a_idx on ab_a1_b1 ab_1 (actual rows=N loops=N)
Index Cond: (a = (a.a + 0))
- -> Index Scan using ab_a1_b2_a_idx on ab_a1_b2 ab_1 (actual rows=N loops=N)
+ -> Index Scan using ab_a1_b2_a_idx on ab_a1_b2 ab_2 (actual rows=N loops=N)
Index Cond: (a = (a.a + 0))
- -> Index Scan using ab_a1_b3_a_idx on ab_a1_b3 ab_2 (actual rows=N loops=N)
+ -> Index Scan using ab_a1_b3_a_idx on ab_a1_b3 ab_3 (actual rows=N loops=N)
Index Cond: (a = (a.a + 0))
- -> Index Scan using ab_a2_b1_a_idx on ab_a2_b1 ab_3 (never executed)
+ -> Index Scan using ab_a2_b1_a_idx on ab_a2_b1 ab_4 (never executed)
Index Cond: (a = (a.a + 0))
- -> Index Scan using ab_a2_b2_a_idx on ab_a2_b2 ab_4 (never executed)
+ -> Index Scan using ab_a2_b2_a_idx on ab_a2_b2 ab_5 (never executed)
Index Cond: (a = (a.a + 0))
- -> Index Scan using ab_a2_b3_a_idx on ab_a2_b3 ab_5 (never executed)
+ -> Index Scan using ab_a2_b3_a_idx on ab_a2_b3 ab_6 (never executed)
Index Cond: (a = (a.a + 0))
- -> Index Scan using ab_a3_b1_a_idx on ab_a3_b1 ab_6 (never executed)
+ -> Index Scan using ab_a3_b1_a_idx on ab_a3_b1 ab_7 (never executed)
Index Cond: (a = (a.a + 0))
- -> Index Scan using ab_a3_b2_a_idx on ab_a3_b2 ab_7 (never executed)
+ -> Index Scan using ab_a3_b2_a_idx on ab_a3_b2 ab_8 (never executed)
Index Cond: (a = (a.a + 0))
- -> Index Scan using ab_a3_b3_a_idx on ab_a3_b3 ab_8 (never executed)
+ -> Index Scan using ab_a3_b3_a_idx on ab_a3_b3 ab_9 (never executed)
Index Cond: (a = (a.a + 0))
(27 rows)
-> Parallel Seq Scan on lprt_a a (actual rows=N loops=N)
Filter: (a = ANY ('{1,0,3}'::integer[]))
-> Append (actual rows=N loops=N)
- -> Index Scan using ab_a1_b1_a_idx on ab_a1_b1 ab (actual rows=N loops=N)
+ -> Index Scan using ab_a1_b1_a_idx on ab_a1_b1 ab_1 (actual rows=N loops=N)
Index Cond: (a = a.a)
- -> Index Scan using ab_a1_b2_a_idx on ab_a1_b2 ab_1 (actual rows=N loops=N)
+ -> Index Scan using ab_a1_b2_a_idx on ab_a1_b2 ab_2 (actual rows=N loops=N)
Index Cond: (a = a.a)
- -> Index Scan using ab_a1_b3_a_idx on ab_a1_b3 ab_2 (actual rows=N loops=N)
+ -> Index Scan using ab_a1_b3_a_idx on ab_a1_b3 ab_3 (actual rows=N loops=N)
Index Cond: (a = a.a)
- -> Index Scan using ab_a2_b1_a_idx on ab_a2_b1 ab_3 (never executed)
+ -> Index Scan using ab_a2_b1_a_idx on ab_a2_b1 ab_4 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a2_b2_a_idx on ab_a2_b2 ab_4 (never executed)
+ -> Index Scan using ab_a2_b2_a_idx on ab_a2_b2 ab_5 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a2_b3_a_idx on ab_a2_b3 ab_5 (never executed)
+ -> Index Scan using ab_a2_b3_a_idx on ab_a2_b3 ab_6 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a3_b1_a_idx on ab_a3_b1 ab_6 (actual rows=N loops=N)
+ -> Index Scan using ab_a3_b1_a_idx on ab_a3_b1 ab_7 (actual rows=N loops=N)
Index Cond: (a = a.a)
- -> Index Scan using ab_a3_b2_a_idx on ab_a3_b2 ab_7 (actual rows=N loops=N)
+ -> Index Scan using ab_a3_b2_a_idx on ab_a3_b2 ab_8 (actual rows=N loops=N)
Index Cond: (a = a.a)
- -> Index Scan using ab_a3_b3_a_idx on ab_a3_b3 ab_8 (actual rows=N loops=N)
+ -> Index Scan using ab_a3_b3_a_idx on ab_a3_b3 ab_9 (actual rows=N loops=N)
Index Cond: (a = a.a)
(27 rows)
Filter: (a = ANY ('{1,0,0}'::integer[]))
Rows Removed by Filter: N
-> Append (actual rows=N loops=N)
- -> Index Scan using ab_a1_b1_a_idx on ab_a1_b1 ab (actual rows=N loops=N)
+ -> Index Scan using ab_a1_b1_a_idx on ab_a1_b1 ab_1 (actual rows=N loops=N)
Index Cond: (a = a.a)
- -> Index Scan using ab_a1_b2_a_idx on ab_a1_b2 ab_1 (actual rows=N loops=N)
+ -> Index Scan using ab_a1_b2_a_idx on ab_a1_b2 ab_2 (actual rows=N loops=N)
Index Cond: (a = a.a)
- -> Index Scan using ab_a1_b3_a_idx on ab_a1_b3 ab_2 (actual rows=N loops=N)
+ -> Index Scan using ab_a1_b3_a_idx on ab_a1_b3 ab_3 (actual rows=N loops=N)
Index Cond: (a = a.a)
- -> Index Scan using ab_a2_b1_a_idx on ab_a2_b1 ab_3 (never executed)
+ -> Index Scan using ab_a2_b1_a_idx on ab_a2_b1 ab_4 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a2_b2_a_idx on ab_a2_b2 ab_4 (never executed)
+ -> Index Scan using ab_a2_b2_a_idx on ab_a2_b2 ab_5 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a2_b3_a_idx on ab_a2_b3 ab_5 (never executed)
+ -> Index Scan using ab_a2_b3_a_idx on ab_a2_b3 ab_6 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a3_b1_a_idx on ab_a3_b1 ab_6 (never executed)
+ -> Index Scan using ab_a3_b1_a_idx on ab_a3_b1 ab_7 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a3_b2_a_idx on ab_a3_b2 ab_7 (never executed)
+ -> Index Scan using ab_a3_b2_a_idx on ab_a3_b2 ab_8 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a3_b3_a_idx on ab_a3_b3 ab_8 (never executed)
+ -> Index Scan using ab_a3_b3_a_idx on ab_a3_b3 ab_9 (never executed)
Index Cond: (a = a.a)
(28 rows)
Filter: (a = ANY ('{1,0,0}'::integer[]))
Rows Removed by Filter: N
-> Append (actual rows=N loops=N)
- -> Index Scan using ab_a1_b1_a_idx on ab_a1_b1 ab (never executed)
+ -> Index Scan using ab_a1_b1_a_idx on ab_a1_b1 ab_1 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a1_b2_a_idx on ab_a1_b2 ab_1 (never executed)
+ -> Index Scan using ab_a1_b2_a_idx on ab_a1_b2 ab_2 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a1_b3_a_idx on ab_a1_b3 ab_2 (never executed)
+ -> Index Scan using ab_a1_b3_a_idx on ab_a1_b3 ab_3 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a2_b1_a_idx on ab_a2_b1 ab_3 (never executed)
+ -> Index Scan using ab_a2_b1_a_idx on ab_a2_b1 ab_4 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a2_b2_a_idx on ab_a2_b2 ab_4 (never executed)
+ -> Index Scan using ab_a2_b2_a_idx on ab_a2_b2 ab_5 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a2_b3_a_idx on ab_a2_b3 ab_5 (never executed)
+ -> Index Scan using ab_a2_b3_a_idx on ab_a2_b3 ab_6 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a3_b1_a_idx on ab_a3_b1 ab_6 (never executed)
+ -> Index Scan using ab_a3_b1_a_idx on ab_a3_b1 ab_7 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a3_b2_a_idx on ab_a3_b2 ab_7 (never executed)
+ -> Index Scan using ab_a3_b2_a_idx on ab_a3_b2 ab_8 (never executed)
Index Cond: (a = a.a)
- -> Index Scan using ab_a3_b3_a_idx on ab_a3_b3 ab_8 (never executed)
+ -> Index Scan using ab_a3_b3_a_idx on ab_a3_b3 ab_9 (never executed)
Index Cond: (a = a.a)
(28 rows)
InitPlan 2 (returns $1)
-> Aggregate (actual rows=1 loops=1)
-> Seq Scan on lprt_a lprt_a_1 (actual rows=102 loops=1)
- -> Bitmap Heap Scan on ab_a1_b1 ab (never executed)
+ -> Bitmap Heap Scan on ab_a1_b1 ab_1 (never executed)
Recheck Cond: (a = $0)
Filter: (b = $1)
-> Bitmap Index Scan on ab_a1_b1_a_idx (never executed)
Index Cond: (a = $0)
- -> Bitmap Heap Scan on ab_a1_b2 ab_1 (never executed)
+ -> Bitmap Heap Scan on ab_a1_b2 ab_2 (never executed)
Recheck Cond: (a = $0)
Filter: (b = $1)
-> Bitmap Index Scan on ab_a1_b2_a_idx (never executed)
Index Cond: (a = $0)
- -> Bitmap Heap Scan on ab_a1_b3 ab_2 (never executed)
+ -> Bitmap Heap Scan on ab_a1_b3 ab_3 (never executed)
Recheck Cond: (a = $0)
Filter: (b = $1)
-> Bitmap Index Scan on ab_a1_b3_a_idx (never executed)
Index Cond: (a = $0)
- -> Bitmap Heap Scan on ab_a2_b1 ab_3 (never executed)
+ -> Bitmap Heap Scan on ab_a2_b1 ab_4 (never executed)
Recheck Cond: (a = $0)
Filter: (b = $1)
-> Bitmap Index Scan on ab_a2_b1_a_idx (never executed)
Index Cond: (a = $0)
- -> Bitmap Heap Scan on ab_a2_b2 ab_4 (never executed)
+ -> Bitmap Heap Scan on ab_a2_b2 ab_5 (never executed)
Recheck Cond: (a = $0)
Filter: (b = $1)
-> Bitmap Index Scan on ab_a2_b2_a_idx (never executed)
Index Cond: (a = $0)
- -> Bitmap Heap Scan on ab_a2_b3 ab_5 (never executed)
+ -> Bitmap Heap Scan on ab_a2_b3 ab_6 (never executed)
Recheck Cond: (a = $0)
Filter: (b = $1)
-> Bitmap Index Scan on ab_a2_b3_a_idx (never executed)
Index Cond: (a = $0)
- -> Bitmap Heap Scan on ab_a3_b1 ab_6 (never executed)
+ -> Bitmap Heap Scan on ab_a3_b1 ab_7 (never executed)
Recheck Cond: (a = $0)
Filter: (b = $1)
-> Bitmap Index Scan on ab_a3_b1_a_idx (never executed)
Index Cond: (a = $0)
- -> Bitmap Heap Scan on ab_a3_b2 ab_7 (actual rows=0 loops=1)
+ -> Bitmap Heap Scan on ab_a3_b2 ab_8 (actual rows=0 loops=1)
Recheck Cond: (a = $0)
Filter: (b = $1)
-> Bitmap Index Scan on ab_a3_b2_a_idx (actual rows=0 loops=1)
Index Cond: (a = $0)
- -> Bitmap Heap Scan on ab_a3_b3 ab_8 (never executed)
+ -> Bitmap Heap Scan on ab_a3_b3 ab_9 (never executed)
Recheck Cond: (a = $0)
Filter: (b = $1)
-> Bitmap Index Scan on ab_a3_b3_a_idx (never executed)
InitPlan 1 (returns $0)
-> Result (actual rows=1 loops=1)
-> Append (actual rows=0 loops=1)
- -> Bitmap Heap Scan on ab_a1_b1 ab_9 (actual rows=0 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b1 ab_11 (actual rows=0 loops=1)
Recheck Cond: (a = 1)
Filter: (b = $0)
-> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1)
Index Cond: (a = 1)
- -> Bitmap Heap Scan on ab_a1_b2 ab_10 (never executed)
+ -> Bitmap Heap Scan on ab_a1_b2 ab_12 (never executed)
Recheck Cond: (a = 1)
Filter: (b = $0)
-> Bitmap Index Scan on ab_a1_b2_a_idx (never executed)
Index Cond: (a = 1)
- -> Bitmap Heap Scan on ab_a1_b3 ab_11 (never executed)
+ -> Bitmap Heap Scan on ab_a1_b3 ab_13 (never executed)
Recheck Cond: (a = 1)
Filter: (b = $0)
-> Bitmap Index Scan on ab_a1_b3_a_idx (never executed)
Index Cond: (a = 1)
- -> Seq Scan on ab_a1_b1 ab (actual rows=0 loops=1)
+ -> Seq Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
Filter: (b = $0)
- -> Seq Scan on ab_a1_b2 ab_1 (never executed)
+ -> Seq Scan on ab_a1_b2 ab_2 (never executed)
Filter: (b = $0)
- -> Seq Scan on ab_a1_b3 ab_2 (never executed)
+ -> Seq Scan on ab_a1_b3 ab_3 (never executed)
Filter: (b = $0)
- -> Seq Scan on ab_a2_b1 ab_3 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_4 (actual rows=0 loops=1)
Filter: (b = $0)
- -> Seq Scan on ab_a2_b2 ab_4 (never executed)
+ -> Seq Scan on ab_a2_b2 ab_5 (never executed)
Filter: (b = $0)
- -> Seq Scan on ab_a2_b3 ab_5 (never executed)
+ -> Seq Scan on ab_a2_b3 ab_6 (never executed)
Filter: (b = $0)
- -> Seq Scan on ab_a3_b1 ab_6 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a3_b1 ab_7 (actual rows=0 loops=1)
Filter: (b = $0)
- -> Seq Scan on ab_a3_b2 ab_7 (never executed)
+ -> Seq Scan on ab_a3_b2 ab_8 (never executed)
Filter: (b = $0)
- -> Seq Scan on ab_a3_b3 ab_8 (never executed)
+ -> Seq Scan on ab_a3_b3 ab_9 (never executed)
Filter: (b = $0)
(37 rows)
InitPlan 1 (returns $0)
-> Result (actual rows=1 loops=1)
-> Append (actual rows=0 loops=1)
- -> Bitmap Heap Scan on ab_a1_b1 ab_9 (actual rows=0 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b1 ab_11 (actual rows=0 loops=1)
Recheck Cond: (a = 1)
Filter: (b = $0)
-> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1)
Index Cond: (a = 1)
- -> Bitmap Heap Scan on ab_a1_b2 ab_10 (never executed)
+ -> Bitmap Heap Scan on ab_a1_b2 ab_12 (never executed)
Recheck Cond: (a = 1)
Filter: (b = $0)
-> Bitmap Index Scan on ab_a1_b2_a_idx (never executed)
Index Cond: (a = 1)
- -> Bitmap Heap Scan on ab_a1_b3 ab_11 (never executed)
+ -> Bitmap Heap Scan on ab_a1_b3 ab_13 (never executed)
Recheck Cond: (a = 1)
Filter: (b = $0)
-> Bitmap Index Scan on ab_a1_b3_a_idx (never executed)
Index Cond: (a = 1)
-> Result (actual rows=0 loops=1)
One-Time Filter: (5 = $0)
- -> Seq Scan on ab_a1_b1 ab (actual rows=0 loops=1)
+ -> Seq Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
Filter: (b = $0)
- -> Seq Scan on ab_a1_b2 ab_1 (never executed)
+ -> Seq Scan on ab_a1_b2 ab_2 (never executed)
Filter: (b = $0)
- -> Seq Scan on ab_a1_b3 ab_2 (never executed)
+ -> Seq Scan on ab_a1_b3 ab_3 (never executed)
Filter: (b = $0)
- -> Seq Scan on ab_a2_b1 ab_3 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_4 (actual rows=0 loops=1)
Filter: (b = $0)
- -> Seq Scan on ab_a2_b2 ab_4 (never executed)
+ -> Seq Scan on ab_a2_b2 ab_5 (never executed)
Filter: (b = $0)
- -> Seq Scan on ab_a2_b3 ab_5 (never executed)
+ -> Seq Scan on ab_a2_b3 ab_6 (never executed)
Filter: (b = $0)
- -> Seq Scan on ab_a3_b1 ab_6 (actual rows=0 loops=1)
+ -> Seq Scan on ab_a3_b1 ab_7 (actual rows=0 loops=1)
Filter: (b = $0)
- -> Seq Scan on ab_a3_b2 ab_7 (never executed)
+ -> Seq Scan on ab_a3_b2 ab_8 (never executed)
Filter: (b = $0)
- -> Seq Scan on ab_a3_b3 ab_8 (never executed)
+ -> Seq Scan on ab_a3_b3 ab_9 (never executed)
Filter: (b = $0)
(39 rows)
InitPlan 1 (returns $0)
-> Result (actual rows=1 loops=1)
Subplans Removed: 12
- -> Seq Scan on ab_a1_b1 ab (never executed)
+ -> Seq Scan on ab_a1_b1 ab_1 (never executed)
Filter: ((a = $1) AND (b = $0))
- -> Seq Scan on ab_a1_b2 ab_1 (never executed)
+ -> Seq Scan on ab_a1_b2 ab_2 (never executed)
Filter: ((a = $1) AND (b = $0))
- -> Seq Scan on ab_a1_b3 ab_2 (never executed)
+ -> Seq Scan on ab_a1_b3 ab_3 (never executed)
Filter: ((a = $1) AND (b = $0))
-> Seq Scan on xy_1 (actual rows=0 loops=1)
Filter: ((x = $1) AND (y = $0))
Rows Removed by Filter: 1
- -> Seq Scan on ab_a1_b1 ab_3 (never executed)
+ -> Seq Scan on ab_a1_b1 ab_4 (never executed)
Filter: ((a = $1) AND (b = $0))
- -> Seq Scan on ab_a1_b2 ab_4 (never executed)
+ -> Seq Scan on ab_a1_b2 ab_5 (never executed)
Filter: ((a = $1) AND (b = $0))
- -> Seq Scan on ab_a1_b3 ab_5 (never executed)
+ -> Seq Scan on ab_a1_b3 ab_6 (never executed)
Filter: ((a = $1) AND (b = $0))
(19 rows)
Update on ab_a1_b3 ab_a1_3
-> Nested Loop (actual rows=0 loops=1)
-> Append (actual rows=1 loops=1)
- -> Bitmap Heap Scan on ab_a1_b1 ab (actual rows=0 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
Recheck Cond: (a = 1)
-> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1)
Index Cond: (a = 1)
- -> Bitmap Heap Scan on ab_a1_b2 ab_1 (actual rows=1 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b2 ab_2 (actual rows=1 loops=1)
Recheck Cond: (a = 1)
Heap Blocks: exact=1
-> Bitmap Index Scan on ab_a1_b2_a_idx (actual rows=1 loops=1)
Index Cond: (a = 1)
- -> Bitmap Heap Scan on ab_a1_b3 ab_2 (actual rows=0 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b3 ab_3 (actual rows=0 loops=1)
Recheck Cond: (a = 1)
-> Bitmap Index Scan on ab_a1_b3_a_idx (actual rows=0 loops=1)
Index Cond: (a = 1)
Index Cond: (a = 1)
-> Nested Loop (actual rows=1 loops=1)
-> Append (actual rows=1 loops=1)
- -> Bitmap Heap Scan on ab_a1_b1 ab (actual rows=0 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
Recheck Cond: (a = 1)
-> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1)
Index Cond: (a = 1)
- -> Bitmap Heap Scan on ab_a1_b2 ab_1 (actual rows=1 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b2 ab_2 (actual rows=1 loops=1)
Recheck Cond: (a = 1)
Heap Blocks: exact=1
-> Bitmap Index Scan on ab_a1_b2_a_idx (actual rows=1 loops=1)
Index Cond: (a = 1)
- -> Bitmap Heap Scan on ab_a1_b3 ab_2 (actual rows=0 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b3 ab_3 (actual rows=0 loops=1)
Recheck Cond: (a = 1)
-> Bitmap Index Scan on ab_a1_b3_a_idx (actual rows=1 loops=1)
Index Cond: (a = 1)
Index Cond: (a = 1)
-> Nested Loop (actual rows=0 loops=1)
-> Append (actual rows=1 loops=1)
- -> Bitmap Heap Scan on ab_a1_b1 ab (actual rows=0 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
Recheck Cond: (a = 1)
-> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1)
Index Cond: (a = 1)
- -> Bitmap Heap Scan on ab_a1_b2 ab_1 (actual rows=1 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b2 ab_2 (actual rows=1 loops=1)
Recheck Cond: (a = 1)
Heap Blocks: exact=1
-> Bitmap Index Scan on ab_a1_b2_a_idx (actual rows=1 loops=1)
Index Cond: (a = 1)
- -> Bitmap Heap Scan on ab_a1_b3 ab_2 (actual rows=0 loops=1)
+ -> Bitmap Heap Scan on ab_a1_b3 ab_3 (actual rows=0 loops=1)
Recheck Cond: (a = 1)
-> Bitmap Index Scan on ab_a1_b3_a_idx (actual rows=1 loops=1)
Index Cond: (a = 1)
insert into ab values (1, 1), (1, 2), (1, 3), (2, 1);
explain (analyze, costs off, summary off, timing off)
update ab_a1 set b = 3 from ab_a2 where ab_a2.b = (select 1);
- QUERY PLAN
-----------------------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------------------
Update on ab_a1 (actual rows=0 loops=1)
Update on ab_a1_b1 ab_a1_1
Update on ab_a1_b2 ab_a1_2
-> Seq Scan on ab_a1_b1 ab_a1_1 (actual rows=1 loops=1)
-> Materialize (actual rows=1 loops=1)
-> Append (actual rows=1 loops=1)
- -> Seq Scan on ab_a2_b1 ab_a2 (actual rows=1 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_a2_1 (actual rows=1 loops=1)
Filter: (b = $0)
- -> Seq Scan on ab_a2_b2 ab_a2_1 (never executed)
+ -> Seq Scan on ab_a2_b2 ab_a2_2 (never executed)
Filter: (b = $0)
- -> Seq Scan on ab_a2_b3 ab_a2_2 (never executed)
+ -> Seq Scan on ab_a2_b3 ab_a2_3 (never executed)
Filter: (b = $0)
-> Nested Loop (actual rows=1 loops=1)
-> Seq Scan on ab_a1_b2 ab_a1_2 (actual rows=1 loops=1)
-> Materialize (actual rows=1 loops=1)
-> Append (actual rows=1 loops=1)
- -> Seq Scan on ab_a2_b1 ab_a2 (actual rows=1 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_a2_1 (actual rows=1 loops=1)
Filter: (b = $0)
- -> Seq Scan on ab_a2_b2 ab_a2_1 (never executed)
+ -> Seq Scan on ab_a2_b2 ab_a2_2 (never executed)
Filter: (b = $0)
- -> Seq Scan on ab_a2_b3 ab_a2_2 (never executed)
+ -> Seq Scan on ab_a2_b3 ab_a2_3 (never executed)
Filter: (b = $0)
-> Nested Loop (actual rows=1 loops=1)
-> Seq Scan on ab_a1_b3 ab_a1_3 (actual rows=1 loops=1)
-> Materialize (actual rows=1 loops=1)
-> Append (actual rows=1 loops=1)
- -> Seq Scan on ab_a2_b1 ab_a2 (actual rows=1 loops=1)
+ -> Seq Scan on ab_a2_b1 ab_a2_1 (actual rows=1 loops=1)
Filter: (b = $0)
- -> Seq Scan on ab_a2_b2 ab_a2_1 (never executed)
+ -> Seq Scan on ab_a2_b2 ab_a2_2 (never executed)
Filter: (b = $0)
- -> Seq Scan on ab_a2_b3 ab_a2_2 (never executed)
+ -> Seq Scan on ab_a2_b3 ab_a2_3 (never executed)
Filter: (b = $0)
(36 rows)
set enable_mergejoin = off;
explain (analyze, costs off, summary off, timing off)
select * from tbl1 join tprt on tbl1.col1 > tprt.col1;
- QUERY PLAN
----------------------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------------------
Nested Loop (actual rows=6 loops=1)
-> Seq Scan on tbl1 (actual rows=2 loops=1)
-> Append (actual rows=3 loops=2)
- -> Index Scan using tprt1_idx on tprt_1 tprt (actual rows=2 loops=2)
+ -> Index Scan using tprt1_idx on tprt_1 (actual rows=2 loops=2)
Index Cond: (col1 < tbl1.col1)
- -> Index Scan using tprt2_idx on tprt_2 tprt_1 (actual rows=2 loops=1)
+ -> Index Scan using tprt2_idx on tprt_2 (actual rows=2 loops=1)
Index Cond: (col1 < tbl1.col1)
- -> Index Scan using tprt3_idx on tprt_3 tprt_2 (never executed)
+ -> Index Scan using tprt3_idx on tprt_3 (never executed)
Index Cond: (col1 < tbl1.col1)
- -> Index Scan using tprt4_idx on tprt_4 tprt_3 (never executed)
+ -> Index Scan using tprt4_idx on tprt_4 (never executed)
Index Cond: (col1 < tbl1.col1)
- -> Index Scan using tprt5_idx on tprt_5 tprt_4 (never executed)
+ -> Index Scan using tprt5_idx on tprt_5 (never executed)
Index Cond: (col1 < tbl1.col1)
- -> Index Scan using tprt6_idx on tprt_6 tprt_5 (never executed)
+ -> Index Scan using tprt6_idx on tprt_6 (never executed)
Index Cond: (col1 < tbl1.col1)
(15 rows)
explain (analyze, costs off, summary off, timing off)
select * from tbl1 join tprt on tbl1.col1 = tprt.col1;
- QUERY PLAN
----------------------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------------------
Nested Loop (actual rows=2 loops=1)
-> Seq Scan on tbl1 (actual rows=2 loops=1)
-> Append (actual rows=1 loops=2)
- -> Index Scan using tprt1_idx on tprt_1 tprt (never executed)
+ -> Index Scan using tprt1_idx on tprt_1 (never executed)
Index Cond: (col1 = tbl1.col1)
- -> Index Scan using tprt2_idx on tprt_2 tprt_1 (actual rows=1 loops=2)
+ -> Index Scan using tprt2_idx on tprt_2 (actual rows=1 loops=2)
Index Cond: (col1 = tbl1.col1)
- -> Index Scan using tprt3_idx on tprt_3 tprt_2 (never executed)
+ -> Index Scan using tprt3_idx on tprt_3 (never executed)
Index Cond: (col1 = tbl1.col1)
- -> Index Scan using tprt4_idx on tprt_4 tprt_3 (never executed)
+ -> Index Scan using tprt4_idx on tprt_4 (never executed)
Index Cond: (col1 = tbl1.col1)
- -> Index Scan using tprt5_idx on tprt_5 tprt_4 (never executed)
+ -> Index Scan using tprt5_idx on tprt_5 (never executed)
Index Cond: (col1 = tbl1.col1)
- -> Index Scan using tprt6_idx on tprt_6 tprt_5 (never executed)
+ -> Index Scan using tprt6_idx on tprt_6 (never executed)
Index Cond: (col1 = tbl1.col1)
(15 rows)
insert into tbl1 values (1001), (1010), (1011);
explain (analyze, costs off, summary off, timing off)
select * from tbl1 inner join tprt on tbl1.col1 > tprt.col1;
- QUERY PLAN
----------------------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------------------
Nested Loop (actual rows=23 loops=1)
-> Seq Scan on tbl1 (actual rows=5 loops=1)
-> Append (actual rows=5 loops=5)
- -> Index Scan using tprt1_idx on tprt_1 tprt (actual rows=2 loops=5)
+ -> Index Scan using tprt1_idx on tprt_1 (actual rows=2 loops=5)
Index Cond: (col1 < tbl1.col1)
- -> Index Scan using tprt2_idx on tprt_2 tprt_1 (actual rows=3 loops=4)
+ -> Index Scan using tprt2_idx on tprt_2 (actual rows=3 loops=4)
Index Cond: (col1 < tbl1.col1)
- -> Index Scan using tprt3_idx on tprt_3 tprt_2 (actual rows=1 loops=2)
+ -> Index Scan using tprt3_idx on tprt_3 (actual rows=1 loops=2)
Index Cond: (col1 < tbl1.col1)
- -> Index Scan using tprt4_idx on tprt_4 tprt_3 (never executed)
+ -> Index Scan using tprt4_idx on tprt_4 (never executed)
Index Cond: (col1 < tbl1.col1)
- -> Index Scan using tprt5_idx on tprt_5 tprt_4 (never executed)
+ -> Index Scan using tprt5_idx on tprt_5 (never executed)
Index Cond: (col1 < tbl1.col1)
- -> Index Scan using tprt6_idx on tprt_6 tprt_5 (never executed)
+ -> Index Scan using tprt6_idx on tprt_6 (never executed)
Index Cond: (col1 < tbl1.col1)
(15 rows)
explain (analyze, costs off, summary off, timing off)
select * from tbl1 inner join tprt on tbl1.col1 = tprt.col1;
- QUERY PLAN
----------------------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------------------
Nested Loop (actual rows=3 loops=1)
-> Seq Scan on tbl1 (actual rows=5 loops=1)
-> Append (actual rows=1 loops=5)
- -> Index Scan using tprt1_idx on tprt_1 tprt (never executed)
+ -> Index Scan using tprt1_idx on tprt_1 (never executed)
Index Cond: (col1 = tbl1.col1)
- -> Index Scan using tprt2_idx on tprt_2 tprt_1 (actual rows=1 loops=2)
+ -> Index Scan using tprt2_idx on tprt_2 (actual rows=1 loops=2)
Index Cond: (col1 = tbl1.col1)
- -> Index Scan using tprt3_idx on tprt_3 tprt_2 (actual rows=0 loops=3)
+ -> Index Scan using tprt3_idx on tprt_3 (actual rows=0 loops=3)
Index Cond: (col1 = tbl1.col1)
- -> Index Scan using tprt4_idx on tprt_4 tprt_3 (never executed)
+ -> Index Scan using tprt4_idx on tprt_4 (never executed)
Index Cond: (col1 = tbl1.col1)
- -> Index Scan using tprt5_idx on tprt_5 tprt_4 (never executed)
+ -> Index Scan using tprt5_idx on tprt_5 (never executed)
Index Cond: (col1 = tbl1.col1)
- -> Index Scan using tprt6_idx on tprt_6 tprt_5 (never executed)
+ -> Index Scan using tprt6_idx on tprt_6 (never executed)
Index Cond: (col1 = tbl1.col1)
(15 rows)
insert into tbl1 values (4400);
explain (analyze, costs off, summary off, timing off)
select * from tbl1 join tprt on tbl1.col1 < tprt.col1;
- QUERY PLAN
----------------------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------------------
Nested Loop (actual rows=1 loops=1)
-> Seq Scan on tbl1 (actual rows=1 loops=1)
-> Append (actual rows=1 loops=1)
- -> Index Scan using tprt1_idx on tprt_1 tprt (never executed)
+ -> Index Scan using tprt1_idx on tprt_1 (never executed)
Index Cond: (col1 > tbl1.col1)
- -> Index Scan using tprt2_idx on tprt_2 tprt_1 (never executed)
+ -> Index Scan using tprt2_idx on tprt_2 (never executed)
Index Cond: (col1 > tbl1.col1)
- -> Index Scan using tprt3_idx on tprt_3 tprt_2 (never executed)
+ -> Index Scan using tprt3_idx on tprt_3 (never executed)
Index Cond: (col1 > tbl1.col1)
- -> Index Scan using tprt4_idx on tprt_4 tprt_3 (never executed)
+ -> Index Scan using tprt4_idx on tprt_4 (never executed)
Index Cond: (col1 > tbl1.col1)
- -> Index Scan using tprt5_idx on tprt_5 tprt_4 (never executed)
+ -> Index Scan using tprt5_idx on tprt_5 (never executed)
Index Cond: (col1 > tbl1.col1)
- -> Index Scan using tprt6_idx on tprt_6 tprt_5 (actual rows=1 loops=1)
+ -> Index Scan using tprt6_idx on tprt_6 (actual rows=1 loops=1)
Index Cond: (col1 > tbl1.col1)
(15 rows)
insert into tbl1 values (10000);
explain (analyze, costs off, summary off, timing off)
select * from tbl1 join tprt on tbl1.col1 = tprt.col1;
- QUERY PLAN
---------------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------
Nested Loop (actual rows=0 loops=1)
-> Seq Scan on tbl1 (actual rows=1 loops=1)
-> Append (actual rows=0 loops=1)
- -> Index Scan using tprt1_idx on tprt_1 tprt (never executed)
+ -> Index Scan using tprt1_idx on tprt_1 (never executed)
Index Cond: (col1 = tbl1.col1)
- -> Index Scan using tprt2_idx on tprt_2 tprt_1 (never executed)
+ -> Index Scan using tprt2_idx on tprt_2 (never executed)
Index Cond: (col1 = tbl1.col1)
- -> Index Scan using tprt3_idx on tprt_3 tprt_2 (never executed)
+ -> Index Scan using tprt3_idx on tprt_3 (never executed)
Index Cond: (col1 = tbl1.col1)
- -> Index Scan using tprt4_idx on tprt_4 tprt_3 (never executed)
+ -> Index Scan using tprt4_idx on tprt_4 (never executed)
Index Cond: (col1 = tbl1.col1)
- -> Index Scan using tprt5_idx on tprt_5 tprt_4 (never executed)
+ -> Index Scan using tprt5_idx on tprt_5 (never executed)
Index Cond: (col1 = tbl1.col1)
- -> Index Scan using tprt6_idx on tprt_6 tprt_5 (never executed)
+ -> Index Scan using tprt6_idx on tprt_6 (never executed)
Index Cond: (col1 = tbl1.col1)
(15 rows)
-- which match the given parameter.
prepare q1 (int,int) as select * from listp where b in ($1,$2);
explain (analyze, costs off, summary off, timing off) execute q1 (1,1);
- QUERY PLAN
------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------
Append (actual rows=0 loops=1)
Subplans Removed: 1
- -> Seq Scan on listp_1_1 listp (actual rows=0 loops=1)
+ -> Seq Scan on listp_1_1 listp_1 (actual rows=0 loops=1)
Filter: (b = ANY (ARRAY[$1, $2]))
(4 rows)
explain (analyze, costs off, summary off, timing off) execute q1 (2,2);
- QUERY PLAN
------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------
Append (actual rows=0 loops=1)
Subplans Removed: 1
- -> Seq Scan on listp_2_1 listp (actual rows=0 loops=1)
+ -> Seq Scan on listp_2_1 listp_1 (actual rows=0 loops=1)
Filter: (b = ANY (ARRAY[$1, $2]))
(4 rows)
-- Try with no matching partitions. One subplan should remain in this case,
-- but it shouldn't be executed.
explain (analyze, costs off, summary off, timing off) execute q1 (0,0);
- QUERY PLAN
-----------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------
Append (actual rows=0 loops=1)
Subplans Removed: 1
- -> Seq Scan on listp_1_1 listp (never executed)
+ -> Seq Scan on listp_1_1 listp_1 (never executed)
Filter: (b = ANY (ARRAY[$1, $2]))
(4 rows)
-------------------------------------------------------------------------
Append (actual rows=0 loops=1)
Subplans Removed: 1
- -> Seq Scan on listp_1_1 listp (actual rows=0 loops=1)
+ -> Seq Scan on listp_1_1 listp_1 (actual rows=0 loops=1)
Filter: ((b = ANY (ARRAY[$1, $2])) AND ($3 <> b) AND ($4 <> b))
(4 rows)
-------------------------------------------------------------------------
Append (actual rows=0 loops=1)
Subplans Removed: 1
- -> Seq Scan on listp_1_1 listp (never executed)
+ -> Seq Scan on listp_1_1 listp_1 (never executed)
Filter: ((b = ANY (ARRAY[$1, $2])) AND ($3 <> b) AND ($4 <> b))
(4 rows)
Append (actual rows=0 loops=1)
InitPlan 1 (returns $0)
-> Result (actual rows=1 loops=1)
- -> Seq Scan on listp_1_1 listp (never executed)
+ -> Seq Scan on listp_1_1 listp_1 (never executed)
Filter: (a = $0)
- -> Seq Scan on listp_2_1 listp_1 (never executed)
+ -> Seq Scan on listp_2_1 listp_2 (never executed)
Filter: (a = $0)
(7 rows)
--------------------------------------------------------------------------------------
Append (actual rows=0 loops=1)
Subplans Removed: 1
- -> Seq Scan on stable_qual_pruning1 stable_qual_pruning (actual rows=0 loops=1)
+ -> Seq Scan on stable_qual_pruning1 stable_qual_pruning_1 (actual rows=0 loops=1)
Filter: (a < LOCALTIMESTAMP)
- -> Seq Scan on stable_qual_pruning2 stable_qual_pruning_1 (actual rows=0 loops=1)
+ -> Seq Scan on stable_qual_pruning2 stable_qual_pruning_2 (actual rows=0 loops=1)
Filter: (a < LOCALTIMESTAMP)
(6 rows)
-- timestamp < timestamptz comparison is only stable, not immutable
explain (analyze, costs off, summary off, timing off)
select * from stable_qual_pruning where a < '2000-02-01'::timestamptz;
- QUERY PLAN
-------------------------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------------------------------
Append (actual rows=0 loops=1)
Subplans Removed: 2
- -> Seq Scan on stable_qual_pruning1 stable_qual_pruning (actual rows=0 loops=1)
+ -> Seq Scan on stable_qual_pruning1 stable_qual_pruning_1 (actual rows=0 loops=1)
Filter: (a < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)
(4 rows)
------------------------------------------------------------------------------------------------------------
Append (actual rows=0 loops=1)
Subplans Removed: 2
- -> Seq Scan on stable_qual_pruning2 stable_qual_pruning (actual rows=0 loops=1)
+ -> Seq Scan on stable_qual_pruning2 stable_qual_pruning_1 (actual rows=0 loops=1)
Filter: (a = ANY (ARRAY['Tue Feb 01 00:00:00 2000'::timestamp without time zone, LOCALTIMESTAMP]))
(4 rows)
---------------------------------------------------------------------------------------------------------------------------
Append (actual rows=0 loops=1)
Subplans Removed: 2
- -> Seq Scan on stable_qual_pruning1 stable_qual_pruning (never executed)
+ -> Seq Scan on stable_qual_pruning1 stable_qual_pruning_1 (never executed)
Filter: (a = ANY ('{"Mon Feb 01 00:00:00 2010 PST","Wed Jan 01 00:00:00 2020 PST"}'::timestamp with time zone[]))
(4 rows)
---------------------------------------------------------------------------------------------------------------------------
Append (actual rows=0 loops=1)
Subplans Removed: 2
- -> Seq Scan on stable_qual_pruning2 stable_qual_pruning (actual rows=0 loops=1)
+ -> Seq Scan on stable_qual_pruning2 stable_qual_pruning_1 (actual rows=0 loops=1)
Filter: (a = ANY ('{"Tue Feb 01 00:00:00 2000 PST","Fri Jan 01 00:00:00 2010 PST"}'::timestamp with time zone[]))
(4 rows)
QUERY PLAN
--------------------------------------------------------------------------------------
Append (actual rows=0 loops=1)
- -> Seq Scan on stable_qual_pruning1 stable_qual_pruning (actual rows=0 loops=1)
+ -> Seq Scan on stable_qual_pruning1 stable_qual_pruning_1 (actual rows=0 loops=1)
Filter: (a = ANY (NULL::timestamp with time zone[]))
- -> Seq Scan on stable_qual_pruning2 stable_qual_pruning_1 (actual rows=0 loops=1)
+ -> Seq Scan on stable_qual_pruning2 stable_qual_pruning_2 (actual rows=0 loops=1)
Filter: (a = ANY (NULL::timestamp with time zone[]))
- -> Seq Scan on stable_qual_pruning3 stable_qual_pruning_2 (actual rows=0 loops=1)
+ -> Seq Scan on stable_qual_pruning3 stable_qual_pruning_3 (actual rows=0 loops=1)
Filter: (a = ANY (NULL::timestamp with time zone[]))
(7 rows)
QUERY PLAN
--------------------------------------------------------
Append (actual rows=3 loops=1)
- -> Seq Scan on mc3p0 mc3p (actual rows=1 loops=1)
+ -> Seq Scan on mc3p0 mc3p_1 (actual rows=1 loops=1)
Filter: ((a < 3) AND (abs(b) = 1))
- -> Seq Scan on mc3p1 mc3p_1 (actual rows=1 loops=1)
+ -> Seq Scan on mc3p1 mc3p_2 (actual rows=1 loops=1)
Filter: ((a < 3) AND (abs(b) = 1))
- -> Seq Scan on mc3p2 mc3p_2 (actual rows=1 loops=1)
+ -> Seq Scan on mc3p2 mc3p_3 (actual rows=1 loops=1)
Filter: ((a < 3) AND (abs(b) = 1))
(7 rows)
select * from mc3p where a = $1 and abs(b) < (select 3);
explain (analyze, costs off, summary off, timing off)
execute ps1(1);
- QUERY PLAN
-------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------
Append (actual rows=1 loops=1)
InitPlan 1 (returns $0)
-> Result (actual rows=1 loops=1)
Subplans Removed: 2
- -> Seq Scan on mc3p1 mc3p (actual rows=1 loops=1)
+ -> Seq Scan on mc3p1 mc3p_1 (actual rows=1 loops=1)
Filter: ((a = $1) AND (abs(b) < $0))
(6 rows)
InitPlan 1 (returns $0)
-> Result (actual rows=1 loops=1)
Subplans Removed: 1
- -> Seq Scan on mc3p0 mc3p (actual rows=1 loops=1)
+ -> Seq Scan on mc3p0 mc3p_1 (actual rows=1 loops=1)
Filter: ((a <= $1) AND (abs(b) < $0))
- -> Seq Scan on mc3p1 mc3p_1 (actual rows=1 loops=1)
+ -> Seq Scan on mc3p1 mc3p_2 (actual rows=1 loops=1)
Filter: ((a <= $1) AND (abs(b) < $0))
(8 rows)
-> Seq Scan on boolvalues (actual rows=1 loops=1)
Filter: value
Rows Removed by Filter: 1
- -> Seq Scan on boolp_f boolp (never executed)
+ -> Seq Scan on boolp_f boolp_1 (never executed)
Filter: (a = $0)
- -> Seq Scan on boolp_t boolp_1 (actual rows=0 loops=1)
+ -> Seq Scan on boolp_t boolp_2 (actual rows=0 loops=1)
Filter: (a = $0)
(9 rows)
explain (analyze, costs off, summary off, timing off)
select * from boolp where a = (select value from boolvalues where not value);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------
Append (actual rows=0 loops=1)
InitPlan 1 (returns $0)
-> Seq Scan on boolvalues (actual rows=1 loops=1)
Filter: (NOT value)
Rows Removed by Filter: 1
- -> Seq Scan on boolp_f boolp (actual rows=0 loops=1)
+ -> Seq Scan on boolp_f boolp_1 (actual rows=0 loops=1)
Filter: (a = $0)
- -> Seq Scan on boolp_t boolp_1 (never executed)
+ -> Seq Scan on boolp_t boolp_2 (never executed)
Filter: (a = $0)
(9 rows)
Merge Append (actual rows=2 loops=1)
Sort Key: ma_test.b
Subplans Removed: 1
- -> Index Scan using ma_test_p2_b_idx on ma_test_p2 ma_test (actual rows=1 loops=1)
+ -> Index Scan using ma_test_p2_b_idx on ma_test_p2 ma_test_1 (actual rows=1 loops=1)
Filter: ((a >= $1) AND ((a % 10) = 5))
Rows Removed by Filter: 9
- -> Index Scan using ma_test_p3_b_idx on ma_test_p3 ma_test_1 (actual rows=1 loops=1)
+ -> Index Scan using ma_test_p3_b_idx on ma_test_p3 ma_test_2 (actual rows=1 loops=1)
Filter: ((a >= $1) AND ((a % 10) = 5))
Rows Removed by Filter: 9
(9 rows)
(2 rows)
explain (analyze, costs off, summary off, timing off) execute mt_q1(25);
- QUERY PLAN
----------------------------------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------------------------------------
Merge Append (actual rows=1 loops=1)
Sort Key: ma_test.b
Subplans Removed: 2
- -> Index Scan using ma_test_p3_b_idx on ma_test_p3 ma_test (actual rows=1 loops=1)
+ -> Index Scan using ma_test_p3_b_idx on ma_test_p3 ma_test_1 (actual rows=1 loops=1)
Filter: ((a >= $1) AND ((a % 10) = 5))
Rows Removed by Filter: 9
(6 rows)
-- Ensure MergeAppend behaves correctly when no subplans match
explain (analyze, costs off, summary off, timing off) execute mt_q1(35);
- QUERY PLAN
---------------------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------
Merge Append (actual rows=0 loops=1)
Sort Key: ma_test.b
Subplans Removed: 2
- -> Index Scan using ma_test_p1_b_idx on ma_test_p1 ma_test (never executed)
+ -> Index Scan using ma_test_p1_b_idx on ma_test_p1 ma_test_1 (never executed)
Filter: ((a >= $1) AND ((a % 10) = 5))
(5 rows)
-> Limit (actual rows=1 loops=1)
-> Index Scan using ma_test_p2_b_idx on ma_test_p2 (actual rows=1 loops=1)
Index Cond: (b IS NOT NULL)
- -> Index Scan using ma_test_p1_b_idx on ma_test_p1 ma_test (never executed)
+ -> Index Scan using ma_test_p1_b_idx on ma_test_p1 ma_test_1 (never executed)
Filter: (a >= $1)
- -> Index Scan using ma_test_p2_b_idx on ma_test_p2 ma_test_1 (actual rows=10 loops=1)
+ -> Index Scan using ma_test_p2_b_idx on ma_test_p2 ma_test_2 (actual rows=10 loops=1)
Filter: (a >= $1)
- -> Index Scan using ma_test_p3_b_idx on ma_test_p3 ma_test_2 (actual rows=10 loops=1)
+ -> Index Scan using ma_test_p3_b_idx on ma_test_p3 ma_test_3 (actual rows=10 loops=1)
Filter: (a >= $1)
(14 rows)
QUERY PLAN
----------------------------------------------------------------------
Append
- -> Seq Scan on pp_arrpart1 pp_arrpart
+ -> Seq Scan on pp_arrpart1 pp_arrpart_1
Filter: ((a = '{4,5}'::integer[]) OR (a = '{1}'::integer[]))
- -> Seq Scan on pp_arrpart2 pp_arrpart_1
+ -> Seq Scan on pp_arrpart2 pp_arrpart_2
Filter: ((a = '{4,5}'::integer[]) OR (a = '{1}'::integer[]))
(5 rows)
QUERY PLAN
----------------------------------------------------------------------
Append
- -> Seq Scan on pph_arrpart1 pph_arrpart
+ -> Seq Scan on pph_arrpart1 pph_arrpart_1
Filter: ((a = '{4,5}'::integer[]) OR (a = '{1}'::integer[]))
- -> Seq Scan on pph_arrpart2 pph_arrpart_1
+ -> Seq Scan on pph_arrpart2 pph_arrpart_2
Filter: ((a = '{4,5}'::integer[]) OR (a = '{1}'::integer[]))
(5 rows)
QUERY PLAN
----------------------------------
Append
- -> Seq Scan on pp_lp1 pp_lp
+ -> Seq Scan on pp_lp1 pp_lp_1
Filter: (a = 1)
- -> Seq Scan on pp_lp2 pp_lp_1
+ -> Seq Scan on pp_lp2 pp_lp_2
Filter: (a = 1)
(5 rows)
QUERY PLAN
----------------------------------
Append
- -> Seq Scan on pp_lp1 pp_lp
+ -> Seq Scan on pp_lp1 pp_lp_1
Filter: (a = 1)
- -> Seq Scan on pp_lp2 pp_lp_1
+ -> Seq Scan on pp_lp2 pp_lp_2
Filter: (a = 1)
(5 rows)
QUERY PLAN
------------------------------------
Append
- -> Seq Scan on inh_lp
+ -> Seq Scan on inh_lp inh_lp_1
Filter: (a = 1)
- -> Seq Scan on inh_lp1 inh_lp_1
+ -> Seq Scan on inh_lp1 inh_lp_2
Filter: (a = 1)
(5 rows)
QUERY PLAN
-----------------------------------------------------
Append
- -> Seq Scan on pp_temp_part_1 pp_temp_parent
- -> Seq Scan on pp_temp_part_def pp_temp_parent_1
+ -> Seq Scan on pp_temp_part_1 pp_temp_parent_1
+ -> Seq Scan on pp_temp_part_def pp_temp_parent_2
(3 rows)
explain (costs off) select * from pp_temp_parent where a = 2;
QUERY PLAN
-------------------------------
Append
- -> Seq Scan on t1
+ -> Seq Scan on t1 t1_1
Filter: ((a % 2) = 0)
- -> Seq Scan on t2 t1_1
+ -> Seq Scan on t2 t1_2
Filter: ((a % 2) = 0)
- -> Seq Scan on t3 t1_2
+ -> Seq Scan on t3 t1_3
Filter: ((a % 2) = 0)
(7 rows)
QUERY PLAN
-----------------------------------------------
Append
- -> Seq Scan on t1
+ -> Seq Scan on t1 t1_1
Filter: (((a % 2) = 0) AND f_leak(b))
- -> Seq Scan on t2 t1_1
+ -> Seq Scan on t2 t1_2
Filter: (((a % 2) = 0) AND f_leak(b))
- -> Seq Scan on t3 t1_2
+ -> Seq Scan on t3 t1_3
Filter: (((a % 2) = 0) AND f_leak(b))
(7 rows)
QUERY PLAN
-------------------------------
Append
- -> Seq Scan on t1
+ -> Seq Scan on t1 t1_1
Filter: ((a % 2) = 0)
- -> Seq Scan on t2 t1_1
+ -> Seq Scan on t2 t1_2
Filter: ((a % 2) = 0)
- -> Seq Scan on t3 t1_2
+ -> Seq Scan on t3 t1_3
Filter: ((a % 2) = 0)
(7 rows)
QUERY PLAN
-------------------------------
Append
- -> Seq Scan on t1
+ -> Seq Scan on t1 t1_1
Filter: ((a % 2) = 0)
- -> Seq Scan on t2 t1_1
+ -> Seq Scan on t2 t1_2
Filter: ((a % 2) = 0)
- -> Seq Scan on t3 t1_2
+ -> Seq Scan on t3 t1_3
Filter: ((a % 2) = 0)
(7 rows)
-------------------------------------
LockRows
-> Append
- -> Seq Scan on t1
+ -> Seq Scan on t1 t1_1
Filter: ((a % 2) = 0)
- -> Seq Scan on t2 t1_1
+ -> Seq Scan on t2 t1_2
Filter: ((a % 2) = 0)
- -> Seq Scan on t3 t1_2
+ -> Seq Scan on t3 t1_3
Filter: ((a % 2) = 0)
(8 rows)
-----------------------------------------------------
LockRows
-> Append
- -> Seq Scan on t1
+ -> Seq Scan on t1 t1_1
Filter: (((a % 2) = 0) AND f_leak(b))
- -> Seq Scan on t2 t1_1
+ -> Seq Scan on t2 t1_2
Filter: (((a % 2) = 0) AND f_leak(b))
- -> Seq Scan on t3 t1_2
+ -> Seq Scan on t3 t1_3
Filter: (((a % 2) = 0) AND f_leak(b))
(8 rows)
QUERY PLAN
---------------------------
Append
- -> Seq Scan on t1
+ -> Seq Scan on t1 t1_1
Filter: f_leak(b)
- -> Seq Scan on t2 t1_1
+ -> Seq Scan on t2 t1_2
Filter: f_leak(b)
- -> Seq Scan on t3 t1_2
+ -> Seq Scan on t3 t1_3
Filter: f_leak(b)
(7 rows)
QUERY PLAN
---------------------------
Append
- -> Seq Scan on t1
+ -> Seq Scan on t1 t1_1
Filter: f_leak(b)
- -> Seq Scan on t2 t1_1
+ -> Seq Scan on t2 t1_2
Filter: f_leak(b)
- -> Seq Scan on t3 t1_2
+ -> Seq Scan on t3 t1_3
Filter: f_leak(b)
(7 rows)
InitPlan 1 (returns $0)
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
- -> Seq Scan on part_document_fiction part_document
+ -> Seq Scan on part_document_fiction part_document_1
Filter: ((dlevel <= $0) AND f_leak(dtitle))
- -> Seq Scan on part_document_satire part_document_1
+ -> Seq Scan on part_document_satire part_document_2
Filter: ((dlevel <= $0) AND f_leak(dtitle))
- -> Seq Scan on part_document_nonfiction part_document_2
+ -> Seq Scan on part_document_nonfiction part_document_3
Filter: ((dlevel <= $0) AND f_leak(dtitle))
(10 rows)
InitPlan 1 (returns $0)
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
- -> Seq Scan on part_document_fiction part_document
+ -> Seq Scan on part_document_fiction part_document_1
Filter: ((dlevel <= $0) AND f_leak(dtitle))
- -> Seq Scan on part_document_satire part_document_1
+ -> Seq Scan on part_document_satire part_document_2
Filter: ((dlevel <= $0) AND f_leak(dtitle))
- -> Seq Scan on part_document_nonfiction part_document_2
+ -> Seq Scan on part_document_nonfiction part_document_3
Filter: ((dlevel <= $0) AND f_leak(dtitle))
(10 rows)
InitPlan 1 (returns $0)
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
- -> Seq Scan on part_document_fiction part_document
+ -> Seq Scan on part_document_fiction part_document_1
Filter: ((dlevel <= $0) AND f_leak(dtitle))
- -> Seq Scan on part_document_satire part_document_1
+ -> Seq Scan on part_document_satire part_document_2
Filter: ((dlevel <= $0) AND f_leak(dtitle))
- -> Seq Scan on part_document_nonfiction part_document_2
+ -> Seq Scan on part_document_nonfiction part_document_3
Filter: ((dlevel <= $0) AND f_leak(dtitle))
(10 rows)
QUERY PLAN
---------------------------------------------------------------
Append
- -> Seq Scan on part_document_fiction part_document
+ -> Seq Scan on part_document_fiction part_document_1
Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle))
- -> Seq Scan on part_document_satire part_document_1
+ -> Seq Scan on part_document_satire part_document_2
Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle))
- -> Seq Scan on part_document_nonfiction part_document_2
+ -> Seq Scan on part_document_nonfiction part_document_3
Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle))
(7 rows)
QUERY PLAN
----------------------------------------------
Append
- -> Seq Scan on t1
+ -> Seq Scan on t1 t1_1
Filter: ((a <= 2) AND ((a % 2) = 0))
- -> Seq Scan on t2 t1_1
+ -> Seq Scan on t2 t1_2
Filter: ((a <= 2) AND ((a % 2) = 0))
- -> Seq Scan on t3 t1_2
+ -> Seq Scan on t3 t1_3
Filter: ((a <= 2) AND ((a % 2) = 0))
(7 rows)
QUERY PLAN
---------------------------
Append
- -> Seq Scan on t1
+ -> Seq Scan on t1 t1_1
Filter: f_leak(b)
- -> Seq Scan on t2 t1_1
+ -> Seq Scan on t2 t1_2
Filter: f_leak(b)
- -> Seq Scan on t3 t1_2
+ -> Seq Scan on t3 t1_3
Filter: f_leak(b)
(7 rows)
QUERY PLAN
---------------------------
Append
- -> Seq Scan on t1
+ -> Seq Scan on t1 t1_1
Filter: (a <= 2)
- -> Seq Scan on t2 t1_1
+ -> Seq Scan on t2 t1_2
Filter: (a <= 2)
- -> Seq Scan on t3 t1_2
+ -> Seq Scan on t3 t1_3
Filter: (a <= 2)
(7 rows)
QUERY PLAN
---------------------------
Append
- -> Seq Scan on t1
+ -> Seq Scan on t1 t1_1
Filter: (a = 2)
- -> Seq Scan on t2 t1_1
+ -> Seq Scan on t2 t1_2
Filter: (a = 2)
- -> Seq Scan on t3 t1_2
+ -> Seq Scan on t3 t1_3
Filter: (a = 2)
(7 rows)
QUERY PLAN
---------------------------------------------
Append
- -> Seq Scan on t1
+ -> Seq Scan on t1 t1_1
Filter: ((a = 2) AND ((a % 2) = 0))
- -> Seq Scan on t2 t1_1
+ -> Seq Scan on t2 t1_2
Filter: ((a = 2) AND ((a % 2) = 0))
- -> Seq Scan on t3 t1_2
+ -> Seq Scan on t3 t1_3
Filter: ((a = 2) AND ((a % 2) = 0))
(7 rows)
-> Seq Scan on t2
Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b))
-> Append
- -> Seq Scan on t1
+ -> Seq Scan on t1 t1_1
Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b))
- -> Seq Scan on t2 t1_1
+ -> Seq Scan on t2 t1_2
Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b))
- -> Seq Scan on t3 t1_2
+ -> Seq Scan on t3 t1_3
Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b))
(11 rows)
-> Seq Scan on t1 t1_1
Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b))
-> Append
- -> Seq Scan on t1 t1_2
+ -> Seq Scan on t1 t1_2_1
Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b))
- -> Seq Scan on t2 t1_2_1
+ -> Seq Scan on t2 t1_2_2
Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b))
- -> Seq Scan on t3 t1_2_2
+ -> Seq Scan on t3 t1_2_3
Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b))
-> Nested Loop
Join Filter: (t1_1_1.b = t1_2.b)
-> Seq Scan on t2 t1_1_1
Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b))
-> Append
- -> Seq Scan on t1 t1_2
+ -> Seq Scan on t1 t1_2_1
Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b))
- -> Seq Scan on t2 t1_2_1
+ -> Seq Scan on t2 t1_2_2
Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b))
- -> Seq Scan on t3 t1_2_2
+ -> Seq Scan on t3 t1_2_3
Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b))
-> Nested Loop
Join Filter: (t1_1_2.b = t1_2.b)
-> Seq Scan on t3 t1_1_2
Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b))
-> Append
- -> Seq Scan on t1 t1_2
+ -> Seq Scan on t1 t1_2_1
Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b))
- -> Seq Scan on t2 t1_2_1
+ -> Seq Scan on t2 t1_2_2
Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b))
- -> Seq Scan on t3 t1_2_2
+ -> Seq Scan on t3 t1_2_3
Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b))
(37 rows)
Workers Planned: 3
-> Partial Aggregate
-> Parallel Append
- -> Parallel Seq Scan on d_star a_star_3
- -> Parallel Seq Scan on f_star a_star_5
- -> Parallel Seq Scan on e_star a_star_4
- -> Parallel Seq Scan on b_star a_star_1
- -> Parallel Seq Scan on c_star a_star_2
- -> Parallel Seq Scan on a_star
+ -> Parallel Seq Scan on d_star a_star_4
+ -> Parallel Seq Scan on f_star a_star_6
+ -> Parallel Seq Scan on e_star a_star_5
+ -> Parallel Seq Scan on b_star a_star_2
+ -> Parallel Seq Scan on c_star a_star_3
+ -> Parallel Seq Scan on a_star a_star_1
(11 rows)
select round(avg(aa)), sum(aa) from a_star a1;
Workers Planned: 3
-> Partial Aggregate
-> Parallel Append
- -> Seq Scan on d_star a_star_3
- -> Seq Scan on c_star a_star_2
- -> Parallel Seq Scan on f_star a_star_5
- -> Parallel Seq Scan on e_star a_star_4
- -> Parallel Seq Scan on b_star a_star_1
- -> Parallel Seq Scan on a_star
+ -> Seq Scan on d_star a_star_4
+ -> Seq Scan on c_star a_star_3
+ -> Parallel Seq Scan on f_star a_star_6
+ -> Parallel Seq Scan on e_star a_star_5
+ -> Parallel Seq Scan on b_star a_star_2
+ -> Parallel Seq Scan on a_star a_star_1
(11 rows)
select round(avg(aa)), sum(aa) from a_star a2;
Workers Planned: 3
-> Partial Aggregate
-> Parallel Append
- -> Seq Scan on d_star a_star_3
- -> Seq Scan on f_star a_star_5
- -> Seq Scan on e_star a_star_4
- -> Seq Scan on b_star a_star_1
- -> Seq Scan on c_star a_star_2
- -> Seq Scan on a_star
+ -> Seq Scan on d_star a_star_4
+ -> Seq Scan on f_star a_star_6
+ -> Seq Scan on e_star a_star_5
+ -> Seq Scan on b_star a_star_2
+ -> Seq Scan on c_star a_star_3
+ -> Seq Scan on a_star a_star_1
(11 rows)
select round(avg(aa)), sum(aa) from a_star a3;
Workers Planned: 1
-> Partial Aggregate
-> Append
- -> Parallel Seq Scan on a_star
- -> Parallel Seq Scan on b_star a_star_1
- -> Parallel Seq Scan on c_star a_star_2
- -> Parallel Seq Scan on d_star a_star_3
- -> Parallel Seq Scan on e_star a_star_4
- -> Parallel Seq Scan on f_star a_star_5
+ -> Parallel Seq Scan on a_star a_star_1
+ -> Parallel Seq Scan on b_star a_star_2
+ -> Parallel Seq Scan on c_star a_star_3
+ -> Parallel Seq Scan on d_star a_star_4
+ -> Parallel Seq Scan on e_star a_star_5
+ -> Parallel Seq Scan on f_star a_star_6
(11 rows)
select round(avg(aa)), sum(aa) from a_star a4;
-> Gather
Workers Planned: 3
-> Parallel Append
- -> Parallel Seq Scan on part_pa_test_p1 pa2
- -> Parallel Seq Scan on part_pa_test_p2 pa2_1
+ -> Parallel Seq Scan on part_pa_test_p1 pa2_1
+ -> Parallel Seq Scan on part_pa_test_p2 pa2_2
SubPlan 2
-> Result
SubPlan 1
-> Append
- -> Seq Scan on part_pa_test_p1 pa1
+ -> Seq Scan on part_pa_test_p1 pa1_1
Filter: (a = pa2.a)
- -> Seq Scan on part_pa_test_p2 pa1_1
+ -> Seq Scan on part_pa_test_p2 pa1_2
Filter: (a = pa2.a)
(14 rows)
-------------------------------------------------
Aggregate
-> Append
- -> Sample Scan on person
+ -> Sample Scan on person person_1
Sampling: bernoulli ('100'::real)
- -> Sample Scan on emp person_1
+ -> Sample Scan on emp person_2
Sampling: bernoulli ('100'::real)
- -> Sample Scan on student person_2
+ -> Sample Scan on student person_3
Sampling: bernoulli ('100'::real)
- -> Sample Scan on stud_emp person_3
+ -> Sample Scan on stud_emp person_4
Sampling: bernoulli ('100'::real)
(10 rows)
create table parted_sample_2 partition of parted_sample for values in (2);
explain (costs off)
select * from parted_sample tablesample bernoulli (100);
- QUERY PLAN
-------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------
Append
- -> Sample Scan on parted_sample_1 parted_sample
+ -> Sample Scan on parted_sample_1
Sampling: bernoulli ('100'::real)
- -> Sample Scan on parted_sample_2 parted_sample_1
+ -> Sample Scan on parted_sample_2
Sampling: bernoulli ('100'::real)
(5 rows)
INSERT INTO other_tbl_child VALUES (8),(100);
EXPLAIN (costs off)
UPDATE rw_view1 SET a = a + 1000 FROM other_tbl_parent WHERE a = id;
- QUERY PLAN
-------------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------------
Update on base_tbl_parent
Update on base_tbl_parent
Update on base_tbl_child base_tbl_parent_1
-> Hash Join
Hash Cond: (other_tbl_parent.id = base_tbl_parent.a)
-> Append
- -> Seq Scan on other_tbl_parent
- -> Seq Scan on other_tbl_child other_tbl_parent_1
+ -> Seq Scan on other_tbl_parent other_tbl_parent_1
+ -> Seq Scan on other_tbl_child other_tbl_parent_2
-> Hash
-> Seq Scan on base_tbl_parent
-> Merge Join
-> Sort
Sort Key: other_tbl_parent.id
-> Append
- -> Seq Scan on other_tbl_parent
- -> Seq Scan on other_tbl_child other_tbl_parent_1
+ -> Seq Scan on other_tbl_parent other_tbl_parent_1
+ -> Seq Scan on other_tbl_child other_tbl_parent_2
(20 rows)
UPDATE rw_view1 SET a = a + 1000 FROM other_tbl_parent WHERE a = id;
Filter: ((t1.a <> 6) AND (alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t1.a) AND leakproof(t1.a))
SubPlan 1
-> Append
- -> Seq Scan on public.t12
- Filter: (t12.a = t1.a)
- -> Seq Scan on public.t111 t12_1
+ -> Seq Scan on public.t12 t12_1
Filter: (t12_1.a = t1.a)
+ -> Seq Scan on public.t111 t12_2
+ Filter: (t12_2.a = t1.a)
SubPlan 2
-> Append
- -> Seq Scan on public.t12 t12_2
- Output: t12_2.a
- -> Seq Scan on public.t111 t12_3
- Output: t12_3.a
+ -> Seq Scan on public.t12 t12_4
+ Output: t12_4.a
+ -> Seq Scan on public.t111 t12_5
+ Output: t12_5.a
-> Index Scan using t11_a_idx on public.t11 t1_1
Output: 100, t1_1.b, t1_1.c, t1_1.d, t1_1.ctid
Index Cond: ((t1_1.a > 5) AND (t1_1.a < 7))
Filter: ((alternatives: SubPlan 1 or hashed SubPlan 2) AND snoop(t1.a) AND leakproof(t1.a))
SubPlan 1
-> Append
- -> Seq Scan on public.t12
- Filter: (t12.a = t1.a)
- -> Seq Scan on public.t111 t12_1
+ -> Seq Scan on public.t12 t12_1
Filter: (t12_1.a = t1.a)
+ -> Seq Scan on public.t111 t12_2
+ Filter: (t12_2.a = t1.a)
SubPlan 2
-> Append
- -> Seq Scan on public.t12 t12_2
- Output: t12_2.a
- -> Seq Scan on public.t111 t12_3
- Output: t12_3.a
+ -> Seq Scan on public.t12 t12_4
+ Output: t12_4.a
+ -> Seq Scan on public.t111 t12_5
+ Output: t12_5.a
-> Index Scan using t11_a_idx on public.t11 t1_1
Output: (t1_1.a + 1), t1_1.b, t1_1.c, t1_1.d, t1_1.ctid
Index Cond: ((t1_1.a > 5) AND (t1_1.a = 8))
projects / postgresql.git / commitdiff