QUERY PLAN
--------------------------------------------------
Foreign Scan
- Output: (InitPlan 1).col1, (sum(ft1.c1))
+ Output: (exists_1).col1, (sum(ft1.c1))
Relations: Aggregate on (public.ft1)
Remote SQL: SELECT sum("C 1") FROM "S 1"."T 1"
- InitPlan 1
+ InitPlan exists_1
-> Seq Scan on pg_catalog.pg_enum
(6 rows)
QUERY PLAN
---------------------------------------------------
GroupAggregate
- Output: (InitPlan 1).col1, sum(ft1.c1)
- InitPlan 1
+ Output: (exists_1).col1, sum(ft1.c1)
+ InitPlan exists_1
-> Seq Scan on pg_catalog.pg_enum
-> Foreign Scan on public.ft1
Output: ft1.c1
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------
Unique
- Output: ((SubPlan 1))
+ Output: ((expr_1))
-> Sort
- Output: ((SubPlan 1))
- Sort Key: ((SubPlan 1))
+ Output: ((expr_1))
+ Sort Key: ((expr_1))
-> Foreign Scan
- Output: (SubPlan 1)
+ Output: (expr_1)
Relations: Aggregate on (public.ft2 t2)
Remote SQL: SELECT count(*) FILTER (WHERE ((c2 = 6) AND ("C 1" < 10))) FROM "S 1"."T 1" WHERE (((c2 % 6) = 0))
- SubPlan 1
+ SubPlan expr_1
-> Foreign Scan on public.ft1 t1
Output: (count(*) FILTER (WHERE ((t2.c2 = 6) AND (t2.c1 < 10))))
Remote SQL: SELECT NULL FROM "S 1"."T 1" WHERE (("C 1" = 6))
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------
Unique
- Output: ((SubPlan 1))
+ Output: ((expr_1))
-> Sort
- Output: ((SubPlan 1))
- Sort Key: ((SubPlan 1))
+ Output: ((expr_1))
+ Sort Key: ((expr_1))
-> Foreign Scan on public.ft2 t2
- Output: (SubPlan 1)
+ Output: (expr_1)
Remote SQL: SELECT "C 1", c2 FROM "S 1"."T 1" WHERE (((c2 % 6) = 0))
- SubPlan 1
+ SubPlan expr_1
-> Foreign Scan
Output: (count(t1.c1) FILTER (WHERE ((t2.c2 = 6) AND (t2.c1 < 10))))
Relations: Aggregate on (public.ft1 t1)
explain (verbose, costs off)
select sum(c2) filter (where c2 in (select c2 from ft1 where c2 < 5)) from ft1;
- QUERY PLAN
--------------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------
Aggregate
- Output: sum(ft1.c2) FILTER (WHERE (ANY (ft1.c2 = (hashed SubPlan 1).col1)))
+ Output: sum(ft1.c2) FILTER (WHERE (ANY (ft1.c2 = (hashed any_1).col1)))
-> Foreign Scan on public.ft1
Output: ft1.c2
Remote SQL: SELECT c2 FROM "S 1"."T 1"
- SubPlan 1
+ SubPlan any_1
-> Foreign Scan on public.ft1 ft1_1
Output: ft1_1.c2
Remote SQL: SELECT c2 FROM "S 1"."T 1" WHERE ((c2 < 5))
Update on public.ft2 target
Remote SQL: UPDATE "S 1"."T 1" SET c2 = $2, c7 = $3 WHERE ctid = $1
-> Foreign Scan on public.ft2 target
- Output: (SubPlan 1).col1, (SubPlan 1).col2, (rescan SubPlan 1), target.ctid, target.*
+ Output: (multiexpr_1).col1, (multiexpr_1).col2, (rescan multiexpr_1), target.ctid, target.*
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8, ctid FROM "S 1"."T 1" WHERE (("C 1" > 1100)) FOR UPDATE
- SubPlan 1
+ SubPlan multiexpr_1
-> Foreign Scan on public.ft2 src
Output: (src.c2 * 10), src.c7
Remote SQL: SELECT c2, c7 FROM "S 1"."T 1" WHERE (($1::integer = "C 1"))
QUERY PLAN
----------------------------------------------------------------------------------------
Nested Loop Left Join
- Output: t1.a, t1.b, t1.c, async_pt.a, async_pt.b, async_pt.c, ((InitPlan 1).col1)
+ Output: t1.a, t1.b, t1.c, async_pt.a, async_pt.b, async_pt.c, ((expr_1).col1)
Join Filter: (t1.a = async_pt.a)
- InitPlan 1
+ InitPlan expr_1
-> Aggregate
Output: count(*)
-> Append
Output: t1.a, t1.b, t1.c
-> Append
-> Async Foreign Scan on public.async_p1 async_pt_1
- Output: async_pt_1.a, async_pt_1.b, async_pt_1.c, (InitPlan 1).col1
+ Output: async_pt_1.a, async_pt_1.b, async_pt_1.c, (expr_1).col1
Remote SQL: SELECT a, b, c FROM public.base_tbl1 WHERE ((a < 3000))
-> Async Foreign Scan on public.async_p2 async_pt_2
- Output: async_pt_2.a, async_pt_2.b, async_pt_2.c, (InitPlan 1).col1
+ Output: async_pt_2.a, async_pt_2.b, async_pt_2.c, (expr_1).col1
Remote SQL: SELECT a, b, c FROM public.base_tbl2 WHERE ((a < 3000))
(20 rows)
Nested Loop Left Join (actual rows=1.00 loops=1)
Join Filter: (t1.a = async_pt.a)
Rows Removed by Join Filter: 399
- InitPlan 1
+ InitPlan expr_1
-> Aggregate (actual rows=1.00 loops=1)
-> Append (actual rows=400.00 loops=1)
-> Async Foreign Scan on async_p1 async_pt_4 (actual rows=200.00 loops=1)
SERVER loopback OPTIONS (table_name 'base_tbl');
EXPLAIN (VERBOSE, COSTS OFF)
SELECT a FROM base_tbl WHERE (a, random() > 0) IN (SELECT a, random() > 0 FROM foreign_tbl);
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------
Seq Scan on public.base_tbl
Output: base_tbl.a
- Filter: (ANY ((base_tbl.a = (SubPlan 1).col1) AND ((random() > '0'::double precision) = (SubPlan 1).col2)))
- SubPlan 1
+ Filter: (ANY ((base_tbl.a = (any_1).col1) AND ((random() > '0'::double precision) = (any_1).col2)))
+ SubPlan any_1
-> Result
Output: base_tbl.a, (random() > '0'::double precision)
-> Append
{
SubPlanState *sps = (SubPlanState *) lfirst(lst);
SubPlan *sp = sps->subplan;
+ char *cooked_plan_name;
/*
* There can be multiple SubPlan nodes referencing the same physical
*/
ancestors = lcons(sp, ancestors);
+ /*
+ * The plan has a name like exists_1 or rowcompare_2, but here we want
+ * to prefix that with CTE, InitPlan, or SubPlan, as appropriate, for
+ * display purposes.
+ */
+ if (sp->subLinkType == CTE_SUBLINK)
+ cooked_plan_name = psprintf("CTE %s", sp->plan_name);
+ else if (sp->isInitPlan)
+ cooked_plan_name = psprintf("InitPlan %s", sp->plan_name);
+ else
+ cooked_plan_name = psprintf("SubPlan %s", sp->plan_name);
+
ExplainNode(sps->planstate, ancestors,
- relationship, sp->plan_name, es);
+ relationship, cooked_plan_name, es);
ancestors = list_delete_first(ancestors);
}
RelOptInfo *sub_final_rel;
Bitmapset *run_cond_attrs = NULL;
ListCell *lc;
+ char *plan_name;
/*
* Must copy the Query so that planning doesn't mess up the RTE contents
Assert(root->plan_params == NIL);
/* Generate a subroot and Paths for the subquery */
- rel->subroot = subquery_planner(root->glob, subquery, root, false,
- tuple_fraction, NULL);
+ plan_name = choose_plan_name(root->glob, rte->eref->aliasname, false);
+ rel->subroot = subquery_planner(root->glob, subquery, plan_name,
+ root, false, tuple_fraction, NULL);
/* Isolate the params needed by this specific subplan */
rel->subplan_params = root->plan_params;
#include "optimizer/pathnode.h"
#include "optimizer/paths.h"
#include "optimizer/planmain.h"
+#include "optimizer/planner.h"
#include "optimizer/subselect.h"
#include "optimizer/tlist.h"
#include "parser/parse_clause.h"
memcpy(subroot, root, sizeof(PlannerInfo));
subroot->query_level++;
subroot->parent_root = root;
+ subroot->plan_name = choose_plan_name(root->glob, "minmax", true);
+
/* reset subplan-related stuff */
subroot->plan_params = NIL;
subroot->outer_params = NULL;
/* and we haven't created PlaceHolderInfos, either */
Assert(subroot->placeholder_list == NIL);
+ /* Add this to list of all PlannerInfo objects. */
+ root->glob->allroots = lappend(root->glob->allroots, root);
+
/*----------
* Generate modified query of the form
* (SELECT col FROM tab
}
/* primary planning entry point (may recurse for subqueries) */
- root = subquery_planner(glob, parse, NULL, false, tuple_fraction, NULL);
+ root = subquery_planner(glob, parse, NULL, NULL, false, tuple_fraction,
+ NULL);
/* Select best Path and turn it into a Plan */
final_rel = fetch_upper_rel(root, UPPERREL_FINAL, NULL);
*--------------------
*/
PlannerInfo *
-subquery_planner(PlannerGlobal *glob, Query *parse, PlannerInfo *parent_root,
- bool hasRecursion, double tuple_fraction,
- SetOperationStmt *setops)
+subquery_planner(PlannerGlobal *glob, Query *parse, char *plan_name,
+ PlannerInfo *parent_root, bool hasRecursion,
+ double tuple_fraction, SetOperationStmt *setops)
{
PlannerInfo *root;
List *newWithCheckOptions;
root->parse = parse;
root->glob = glob;
root->query_level = parent_root ? parent_root->query_level + 1 : 1;
+ root->plan_name = plan_name;
root->parent_root = parent_root;
root->plan_params = NIL;
root->outer_params = NULL;
root->non_recursive_path = NULL;
root->partColsUpdated = false;
+ /* Add this to list of all PlannerInfo objects. */
+ root->glob->allroots = lappend(root->glob->allroots, root);
+
/*
* Create the top-level join domain. This won't have valid contents until
* deconstruct_jointree fills it in, but the node needs to exist before
return grouplist;
}
+
+/*
+ * Choose a unique plan name for subroot.
+ */
+char *
+choose_plan_name(PlannerGlobal *glob, char *name, bool always_number)
+{
+ unsigned n;
+
+ /*
+ * If a numeric suffix is not required, then search the list of roots for
+ * a plan with the requested name. If none is found, then we can use the
+ * provided name without modification.
+ */
+ if (!always_number)
+ {
+ bool found = false;
+
+ foreach_node(PlannerInfo, root, glob->allroots)
+ {
+ if (root->plan_name != NULL &&
+ strcmp(name, root->plan_name) == 0)
+ {
+ found = true;
+ break;
+ }
+ }
+
+ if (!found)
+ return name;
+ }
+
+ /*
+ * If a numeric suffix is required or if the un-suffixed name is already
+ * in use, then loop until we find a positive integer that produces a
+ * novel name.
+ */
+ for (n = 1; true; ++n)
+ {
+ char *proposed_name = psprintf("%s_%u", name, n);
+ bool found = false;
+
+ foreach_node(PlannerInfo, root, glob->allroots)
+ {
+ if (root->plan_name != NULL &&
+ strcmp(proposed_name, root->plan_name) == 0)
+ {
+ found = true;
+ break;
+ }
+ }
+
+ if (!found)
+ return proposed_name;
+
+ pfree(proposed_name);
+ }
+}
Bitmapset *scan_params);
static bool finalize_primnode(Node *node, finalize_primnode_context *context);
static bool finalize_agg_primnode(Node *node, finalize_primnode_context *context);
+static char *sublinktype_to_string(SubLinkType subLinkType);
/*
Plan *plan;
List *plan_params;
Node *result;
+ char *sublinkstr = sublinktype_to_string(subLinkType);
/*
* Copy the source Query node. This is a quick and dirty kluge to resolve
Assert(root->plan_params == NIL);
/* Generate Paths for the subquery */
- subroot = subquery_planner(root->glob, subquery, root, false,
- tuple_fraction, NULL);
+ subroot = subquery_planner(root->glob, subquery,
+ choose_plan_name(root->glob, sublinkstr, true),
+ root, false, tuple_fraction, NULL);
/* Isolate the params needed by this specific subplan */
plan_params = root->plan_params;
&newtestexpr, ¶mIds);
if (subquery)
{
+ char *plan_name;
+
/* Generate Paths for the ANY subquery; we'll need all rows */
- subroot = subquery_planner(root->glob, subquery, root, false, 0.0,
- NULL);
+ plan_name = choose_plan_name(root->glob, sublinkstr, true);
+ subroot = subquery_planner(root->glob, subquery, plan_name,
+ root, false, 0.0, NULL);
/* Isolate the params needed by this specific subplan */
plan_params = root->plan_params;
{
Node *result;
SubPlan *splan;
- bool isInitPlan;
ListCell *lc;
/*
- * Initialize the SubPlan node. Note plan_id, plan_name, and cost fields
- * are set further down.
+ * Initialize the SubPlan node.
+ *
+ * Note: plan_id and cost fields are set further down.
*/
splan = makeNode(SubPlan);
splan->subLinkType = subLinkType;
+ splan->plan_name = subroot->plan_name;
splan->testexpr = NULL;
splan->paramIds = NIL;
get_first_col_type(plan, &splan->firstColType, &splan->firstColTypmod,
Assert(testexpr == NULL);
prm = generate_new_exec_param(root, BOOLOID, -1, InvalidOid);
splan->setParam = list_make1_int(prm->paramid);
- isInitPlan = true;
+ splan->isInitPlan = true;
result = (Node *) prm;
}
else if (splan->parParam == NIL && subLinkType == EXPR_SUBLINK)
exprTypmod((Node *) te->expr),
exprCollation((Node *) te->expr));
splan->setParam = list_make1_int(prm->paramid);
- isInitPlan = true;
+ splan->isInitPlan = true;
result = (Node *) prm;
}
else if (splan->parParam == NIL && subLinkType == ARRAY_SUBLINK)
exprTypmod((Node *) te->expr),
exprCollation((Node *) te->expr));
splan->setParam = list_make1_int(prm->paramid);
- isInitPlan = true;
+ splan->isInitPlan = true;
result = (Node *) prm;
}
else if (splan->parParam == NIL && subLinkType == ROWCOMPARE_SUBLINK)
testexpr,
params);
splan->setParam = list_copy(splan->paramIds);
- isInitPlan = true;
+ splan->isInitPlan = true;
/*
* The executable expression is returned to become part of the outer
/* It can be an initplan if there are no parParams. */
if (splan->parParam == NIL)
{
- isInitPlan = true;
+ splan->isInitPlan = true;
result = (Node *) makeNullConst(RECORDOID, -1, InvalidOid);
}
else
{
- isInitPlan = false;
+ splan->isInitPlan = false;
result = (Node *) splan;
}
}
plan = materialize_finished_plan(plan);
result = (Node *) splan;
- isInitPlan = false;
+ splan->isInitPlan = false;
}
/*
root->glob->subroots = lappend(root->glob->subroots, subroot);
splan->plan_id = list_length(root->glob->subplans);
- if (isInitPlan)
+ if (splan->isInitPlan)
root->init_plans = lappend(root->init_plans, splan);
/*
* there's no point since it won't get re-run without parameter changes
* anyway. The input of a hashed subplan doesn't need REWIND either.
*/
- if (splan->parParam == NIL && !isInitPlan && !splan->useHashTable)
+ if (splan->parParam == NIL && !splan->isInitPlan && !splan->useHashTable)
root->glob->rewindPlanIDs = bms_add_member(root->glob->rewindPlanIDs,
splan->plan_id);
- /* Label the subplan for EXPLAIN purposes */
- splan->plan_name = psprintf("%s %d",
- isInitPlan ? "InitPlan" : "SubPlan",
- splan->plan_id);
-
/* Lastly, fill in the cost estimates for use later */
cost_subplan(root, splan, plan);
* Generate Paths for the CTE query. Always plan for full retrieval
* --- we don't have enough info to predict otherwise.
*/
- subroot = subquery_planner(root->glob, subquery, root,
+ subroot = subquery_planner(root->glob, subquery, cte->ctename, root,
cte->cterecursive, 0.0, NULL);
/*
* Make a SubPlan node for it. This is just enough unlike
* build_subplan that we can't share code.
*
- * Note plan_id, plan_name, and cost fields are set further down.
+ * Note: plan_id and cost fields are set further down.
*/
splan = makeNode(SubPlan);
splan->subLinkType = CTE_SUBLINK;
+ splan->plan_name = subroot->plan_name;
splan->testexpr = NULL;
splan->paramIds = NIL;
get_first_col_type(plan, &splan->firstColType, &splan->firstColTypmod,
root->cte_plan_ids = lappend_int(root->cte_plan_ids, splan->plan_id);
- /* Label the subplan for EXPLAIN purposes */
- splan->plan_name = psprintf("CTE %s", cte->ctename);
-
/* Lastly, fill in the cost estimates for use later */
cost_subplan(root, splan, plan);
}
node = makeNode(SubPlan);
node->subLinkType = EXPR_SUBLINK;
node->plan_id = list_length(root->glob->subplans);
- node->plan_name = psprintf("InitPlan %d", node->plan_id);
+ node->plan_name = subroot->plan_name;
+ node->isInitPlan = true;
get_first_col_type(plan, &node->firstColType, &node->firstColTypmod,
&node->firstColCollation);
node->parallel_safe = plan->parallel_safe;
/* Set costs of SubPlan using info from the plan tree */
cost_subplan(subroot, node, plan);
}
+
+/*
+ * Get a string equivalent of a given subLinkType.
+ */
+static char *
+sublinktype_to_string(SubLinkType subLinkType)
+{
+ switch (subLinkType)
+ {
+ case EXISTS_SUBLINK:
+ return "exists";
+ case ALL_SUBLINK:
+ return "all";
+ case ANY_SUBLINK:
+ return "any";
+ case ROWCOMPARE_SUBLINK:
+ return "rowcompare";
+ case EXPR_SUBLINK:
+ return "expr";
+ case MULTIEXPR_SUBLINK:
+ return "multiexpr";
+ case ARRAY_SUBLINK:
+ return "array";
+ case CTE_SUBLINK:
+ return "cte";
+ }
+ Assert(false);
+}
subroot->parse = subquery;
subroot->glob = root->glob;
subroot->query_level = root->query_level;
+ subroot->plan_name = root->plan_name;
subroot->parent_root = root->parent_root;
subroot->plan_params = NIL;
subroot->outer_params = NULL;
subroot->non_recursive_path = NULL;
/* We don't currently need a top JoinDomain for the subroot */
+ /* Add new subroot to master list of PlannerInfo objects. */
+ root->glob->allroots = lappend(root->glob->allroots, subroot);
+
/* No CTEs to worry about */
Assert(subquery->cteList == NIL);
PlannerInfo *subroot;
List *tlist;
bool trivial_tlist;
+ char *plan_name;
Assert(subquery != NULL);
* parentOp, pass that down to encourage subquery_planner to consider
* suitably-sorted Paths.
*/
- subroot = rel->subroot = subquery_planner(root->glob, subquery, root,
+ plan_name = choose_plan_name(root->glob, "setop", true);
+ subroot = rel->subroot = subquery_planner(root->glob, subquery,
+ plan_name, root,
false, root->tuple_fraction,
parentOp);
/* PlannerInfos for SubPlan nodes */
List *subroots pg_node_attr(read_write_ignore);
+ /* every PlannerInfo regardless of whether it's an InitPlan/SubPlan */
+ List *allroots pg_node_attr(read_write_ignore);
+
/* indices of subplans that require REWIND */
Bitmapset *rewindPlanIDs;
/* NULL at outermost Query */
PlannerInfo *parent_root pg_node_attr(read_write_ignore);
+ /* Name for EXPLAIN and debugging purposes */
+ char *plan_name;
+
/*
* plan_params contains the expressions that this query level needs to
* make available to a lower query level that is currently being planned.
Oid firstColCollation; /* Collation of first column of subplan
* result */
/* Information about execution strategy: */
+ bool isInitPlan; /* true if it's an InitPlan */
bool useHashTable; /* true to store subselect output in a hash
* table (implies we are doing "IN") */
bool unknownEqFalse; /* true if it's okay to return FALSE when the
ParamListInfo boundParams);
extern PlannerInfo *subquery_planner(PlannerGlobal *glob, Query *parse,
- PlannerInfo *parent_root,
+ char *plan_name, PlannerInfo *parent_root,
bool hasRecursion, double tuple_fraction,
SetOperationStmt *setops);
extern Expr *preprocess_phv_expression(PlannerInfo *root, Expr *expr);
+extern char *choose_plan_name(PlannerGlobal *glob, char *name,
+ bool always_number);
+
#endif /* PLANNER_H */
QUERY PLAN
-------------------------------------------------------------------
Function Scan on pg_catalog.generate_series x
- Output: ARRAY(SubPlan 1)
+ Output: ARRAY(array_1)
Function Call: generate_series(1, 3)
- SubPlan 1
+ SubPlan array_1
-> Sort
Output: (sum((x.x + y.y))), y.y
Sort Key: (sum((x.x + y.y)))
------------------------------------------------------------
Result
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan using tenk1_unique1 on tenk1
Index Cond: (unique1 IS NOT NULL)
---------------------------------------------------------------------
Result
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique1 on tenk1
Index Cond: (unique1 IS NOT NULL)
------------------------------------------------------------------------
Result
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique1 on tenk1
Index Cond: ((unique1 IS NOT NULL) AND (unique1 < 42))
------------------------------------------------------------------------
Result
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique1 on tenk1
Index Cond: ((unique1 IS NOT NULL) AND (unique1 > 42))
---------------------------------------------------------------------------
Result
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique1 on tenk1
Index Cond: ((unique1 IS NOT NULL) AND (unique1 > 42000))
----------------------------------------------------------------------------
Result
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_thous_tenthous on tenk1
Index Cond: ((thousand = 33) AND (tenthous IS NOT NULL))
--------------------------------------------------------------------------
Result
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan using tenk1_thous_tenthous on tenk1
Index Cond: ((thousand = 33) AND (tenthous IS NOT NULL))
QUERY PLAN
-----------------------------------------------------------------------------------------
Seq Scan on int4_tbl
- SubPlan 2
+ SubPlan expr_1
-> Result
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan using tenk1_unique1 on tenk1
Index Cond: ((unique1 IS NOT NULL) AND (unique1 > int4_tbl.f1))
QUERY PLAN
---------------------------------------------------------------------
HashAggregate
- Group Key: (InitPlan 1).col1
- InitPlan 1
+ Group Key: (minmax_1).col1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique2 on tenk1
Index Cond: (unique2 IS NOT NULL)
QUERY PLAN
---------------------------------------------------------------------
Sort
- Sort Key: ((InitPlan 1).col1)
- InitPlan 1
+ Sort Key: ((minmax_1).col1)
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique2 on tenk1
Index Cond: (unique2 IS NOT NULL)
QUERY PLAN
---------------------------------------------------------------------
Sort
- Sort Key: ((InitPlan 1).col1)
- InitPlan 1
+ Sort Key: ((minmax_1).col1)
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique2 on tenk1
Index Cond: (unique2 IS NOT NULL)
QUERY PLAN
---------------------------------------------------------------------
Sort
- Sort Key: (((InitPlan 1).col1 + 1))
- InitPlan 1
+ Sort Key: (((minmax_1).col1 + 1))
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique2 on tenk1
Index Cond: (unique2 IS NOT NULL)
---------------------------------------------------------------------
Sort
Sort Key: (generate_series(1, 3)) DESC
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using tenk1_unique2 on tenk1
Index Cond: (unique2 IS NOT NULL)
----------------------------------------------------
Result
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Result
One-Time Filter: (100 IS NOT NULL)
---------------------------------------------------------------------------------------------
Result
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Merge Append
Sort Key: minmaxtest.f1
-> Index Only Scan Backward using minmaxtest2i on minmaxtest2 minmaxtest_3
Index Cond: (f1 IS NOT NULL)
-> Index Only Scan using minmaxtest3i on minmaxtest3 minmaxtest_4
- InitPlan 2
+ InitPlan minmax_1
-> Limit
-> Merge Append
Sort Key: minmaxtest_5.f1 DESC
QUERY PLAN
---------------------------------------------------------------------------------------------
Unique
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Merge Append
Sort Key: minmaxtest.f1
-> Index Only Scan Backward using minmaxtest2i on minmaxtest2 minmaxtest_3
Index Cond: (f1 IS NOT NULL)
-> Index Only Scan using minmaxtest3i on minmaxtest3 minmaxtest_4
- InitPlan 2
+ InitPlan minmax_1
-> Limit
-> Merge Append
Sort Key: minmaxtest_5.f1 DESC
Index Cond: (f1 IS NOT NULL)
-> Index Only Scan Backward using minmaxtest3i on minmaxtest3 minmaxtest_9
-> Sort
- Sort Key: ((InitPlan 1).col1), ((InitPlan 2).col1)
+ Sort Key: ((minmax_1).col1), ((minmax_1).col1)
-> Result
Replaces: Aggregate
(27 rows)
QUERY PLAN
---------------------------------------------------------------------
Seq Scan on int4_tbl t0
- SubPlan 2
+ SubPlan expr_1
-> HashAggregate
- Group Key: (InitPlan 1).col1
- InitPlan 1
+ Group Key: (minmax_1).col1
+ InitPlan minmax_1
-> Limit
-> Seq Scan on int4_tbl t1
Filter: ((f1 IS NOT NULL) AND (f1 = t0.f1))
QUERY PLAN
--------------------------------------------------------------------------------------------
Function Scan on generate_series x
- SubPlan 1
+ SubPlan expr_1
-> Limit
-> Index Scan using ggpolygonind on gpolygon_tbl
Order By: (f1 <-> point((x.x)::double precision, (x.x)::double precision))
EXPLAIN (COSTS OFF)
SELECT * FROM tenk1
WHERE thousand = 42 AND (tenthous = 1 OR tenthous = (SELECT 1 + 2) OR tenthous = 42);
- QUERY PLAN
-----------------------------------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------------------------
Index Scan using tenk1_thous_tenthous on tenk1
- Index Cond: ((thousand = 42) AND (tenthous = ANY (ARRAY[1, (InitPlan 1).col1, 42])))
- InitPlan 1
+ Index Cond: ((thousand = 42) AND (tenthous = ANY (ARRAY[1, (expr_1).col1, 42])))
+ InitPlan expr_1
-> Result
(4 rows)
----------------------------------------------------------------------------
Aggregate
-> Index Only Scan using tenk1_thous_tenthous on tenk1 t1
- Filter: ((thousand = 42) OR (thousand = (SubPlan 1)))
- SubPlan 1
+ Filter: ((thousand = 42) OR (thousand = (expr_1)))
+ SubPlan expr_1
-> Limit
-> Index Only Scan using tenk1_thous_tenthous on tenk1 t2
Index Cond: (thousand = (t1.tenthous + 1))
from int8_tbl i1
cross join lateral (select (select i1.q1) as x) ss
group by ss.x;
- QUERY PLAN
-------------------------------------------------
+ QUERY PLAN
+--------------------------------------------
GroupAggregate
- Output: GROUPING((SubPlan 1)), ((SubPlan 2))
- Group Key: ((SubPlan 2))
+ Output: GROUPING((expr_1)), ((expr_2))
+ Group Key: ((expr_2))
-> Sort
- Output: ((SubPlan 2)), i1.q1
- Sort Key: ((SubPlan 2))
+ Output: ((expr_2)), i1.q1
+ Sort Key: ((expr_2))
-> Seq Scan on public.int8_tbl i1
- Output: (SubPlan 2), i1.q1
- SubPlan 2
+ Output: (expr_2), i1.q1
+ SubPlan expr_2
-> Result
Output: i1.q1
(11 rows)
QUERY PLAN
--------------------------------------------
GroupAggregate
- Output: (SubPlan 2), ((SubPlan 3))
- Group Key: ((SubPlan 3))
+ Output: (expr_1), ((expr_3))
+ Group Key: ((expr_3))
-> Sort
- Output: ((SubPlan 3)), i1.q1
- Sort Key: ((SubPlan 3))
+ Output: ((expr_3)), i1.q1
+ Sort Key: ((expr_3))
-> Seq Scan on public.int8_tbl i1
- Output: (SubPlan 3), i1.q1
- SubPlan 3
+ Output: (expr_3), i1.q1
+ SubPlan expr_3
-> Result
Output: i1.q1
- SubPlan 2
+ SubPlan expr_1
-> Result
- Output: GROUPING((SubPlan 1))
+ Output: GROUPING((expr_2))
(14 rows)
select (select grouping(ss.x))
------------------------------------------------------------
Result
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan using tenk1_unique1 on tenk1
Index Cond: (unique1 IS NOT NULL)
Sort
Sort Key: "*VALUES*".column1
-> Values Scan on "*VALUES*"
- SubPlan 1
+ SubPlan expr_1
-> Aggregate
Group Key: ()
Filter: "*VALUES*".column1
-- test handling of outer GroupingFunc within subqueries
explain (costs off)
select (select grouping(v1)) from (values ((select 1))) v(v1) group by cube(v1);
- QUERY PLAN
--------------------------------
+ QUERY PLAN
+---------------------------
MixedAggregate
- Hash Key: (InitPlan 3).col1
+ Hash Key: (expr_3).col1
Group Key: ()
- InitPlan 1
+ InitPlan expr_2
-> Result
- InitPlan 3
+ InitPlan expr_3
-> Result
-> Result
- SubPlan 2
+ SubPlan expr_1
-> Result
(10 rows)
explain (costs off)
select (select grouping(v1)) from (values ((select 1))) v(v1) group by v1;
- QUERY PLAN
-----------------
+ QUERY PLAN
+-------------------
GroupAggregate
- InitPlan 1
+ InitPlan expr_2
-> Result
- InitPlan 3
+ InitPlan expr_3
-> Result
-> Result
- SubPlan 2
+ SubPlan expr_1
-> Result
(8 rows)
then (select t1.v from gstest5 t2 where id = t1.id)
else null end
nulls first;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------
Sort
- Output: (GROUPING((SubPlan 1))), ((SubPlan 3)), (CASE WHEN (GROUPING((SubPlan 2)) = 0) THEN ((SubPlan 3)) ELSE NULL::integer END), t1.v
- Sort Key: (CASE WHEN (GROUPING((SubPlan 2)) = 0) THEN ((SubPlan 3)) ELSE NULL::integer END) NULLS FIRST
+ Output: (GROUPING((expr_1))), ((expr_3)), (CASE WHEN (GROUPING((expr_2)) = 0) THEN ((expr_3)) ELSE NULL::integer END), t1.v
+ Sort Key: (CASE WHEN (GROUPING((expr_2)) = 0) THEN ((expr_3)) ELSE NULL::integer END) NULLS FIRST
-> HashAggregate
- Output: GROUPING((SubPlan 1)), ((SubPlan 3)), CASE WHEN (GROUPING((SubPlan 2)) = 0) THEN ((SubPlan 3)) ELSE NULL::integer END, t1.v
+ Output: GROUPING((expr_1)), ((expr_3)), CASE WHEN (GROUPING((expr_2)) = 0) THEN ((expr_3)) ELSE NULL::integer END, t1.v
Hash Key: t1.v
- Hash Key: (SubPlan 3)
+ Hash Key: (expr_3)
-> Seq Scan on pg_temp.gstest5 t1
- Output: (SubPlan 3), t1.v, t1.id
- SubPlan 3
+ Output: (expr_3), t1.v, t1.id
+ SubPlan expr_3
-> Bitmap Heap Scan on pg_temp.gstest5 t2
Output: t1.v
Recheck Cond: (t2.id = t1.id)
from gstest5 t1
group by grouping sets(v, s)
order by o nulls first;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------
Sort
- Output: (GROUPING((SubPlan 1))), ((SubPlan 3)), (CASE WHEN (GROUPING((SubPlan 2)) = 0) THEN ((SubPlan 3)) ELSE NULL::integer END), t1.v
- Sort Key: (CASE WHEN (GROUPING((SubPlan 2)) = 0) THEN ((SubPlan 3)) ELSE NULL::integer END) NULLS FIRST
+ Output: (GROUPING((expr_1))), ((expr_3)), (CASE WHEN (GROUPING((expr_2)) = 0) THEN ((expr_3)) ELSE NULL::integer END), t1.v
+ Sort Key: (CASE WHEN (GROUPING((expr_2)) = 0) THEN ((expr_3)) ELSE NULL::integer END) NULLS FIRST
-> HashAggregate
- Output: GROUPING((SubPlan 1)), ((SubPlan 3)), CASE WHEN (GROUPING((SubPlan 2)) = 0) THEN ((SubPlan 3)) ELSE NULL::integer END, t1.v
+ Output: GROUPING((expr_1)), ((expr_3)), CASE WHEN (GROUPING((expr_2)) = 0) THEN ((expr_3)) ELSE NULL::integer END, t1.v
Hash Key: t1.v
- Hash Key: (SubPlan 3)
+ Hash Key: (expr_3)
-> Seq Scan on pg_temp.gstest5 t1
- Output: (SubPlan 3), t1.v, t1.id
- SubPlan 3
+ Output: (expr_3), t1.v, t1.id
+ SubPlan expr_3
-> Bitmap Heap Scan on pg_temp.gstest5 t2
Output: t1.v
Recheck Cond: (t2.id = t1.id)
---------------------------------------------------------------------------------
Unique
-> Sort
- Sort Key: t.unique1, ((SubPlan 1))
+ Sort Key: t.unique1, ((expr_1))
-> Gather
Workers Planned: 2
-> Nested Loop
-> Parallel Index Only Scan using tenk1_unique1 on tenk1 t
-> Function Scan on generate_series
- SubPlan 1
+ SubPlan expr_1
-> Index Only Scan using tenk1_unique1 on tenk1
Index Cond: (unique1 = t.unique1)
(11 rows)
QUERY PLAN
---------------------------------------------------------------------------
Sort
- Sort Key: t.unique1, ((SubPlan 1))
+ Sort Key: t.unique1, ((expr_1))
-> Gather
Workers Planned: 2
-> Nested Loop
-> Parallel Index Only Scan using tenk1_unique1 on tenk1 t
-> Function Scan on generate_series
- SubPlan 1
+ SubPlan expr_1
-> Index Only Scan using tenk1_unique1 on tenk1
Index Cond: (unique1 = t.unique1)
(10 rows)
QUERY PLAN
---------------------------------------------------------------------------------
Result
- Output: (InitPlan 1).col1
+ Output: (minmax_1).col1
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
Output: ((1 - matest0.id))
-> Result
--------------------------------------------------------------------
Result
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Merge Append
Sort Key: a.unique1
--------------------------------------------------------------------
Result
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Merge Append
Sort Key: a.unique1
QUERY PLAN
----------------------------------------------------------------
Function Scan on generate_series g
- SubPlan 1
+ SubPlan array_1
-> Limit
-> Merge Append
Sort Key: ((d.d + g.i))
insert into inhcld select x::text, x from generate_series(6,10) x;
explain (verbose, costs off)
update inhpar i set (f1, f2) = (select i.f1, i.f2 || '-' from int4_tbl limit 1);
- QUERY PLAN
---------------------------------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------
Update on public.inhpar i
Update on public.inhpar i_1
Update on public.inhcld i_2
-> Result
- Output: (SubPlan 1).col1, (SubPlan 1).col2, (rescan SubPlan 1), i.tableoid, i.ctid
+ Output: (multiexpr_1).col1, (multiexpr_1).col2, (rescan multiexpr_1), i.tableoid, i.ctid
-> Append
-> Seq Scan on public.inhpar i_1
Output: i_1.f1, i_1.f2, i_1.tableoid, i_1.ctid
-> Seq Scan on public.inhcld i_2
Output: i_2.f1, i_2.f2, i_2.tableoid, i_2.ctid
- SubPlan 1
+ SubPlan multiexpr_1
-> Limit
Output: (i.f1), (((i.f2)::text || '-'::text))
-> Seq Scan on public.int4_tbl
insert into inhpar select x, x::text from generate_series(1,10) x;
explain (verbose, costs off)
update inhpar i set (f1, f2) = (select i.f1, i.f2 || '-' from int4_tbl limit 1);
- QUERY PLAN
-------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------
Update on public.inhpar i
Update on public.inhcld1 i_1
Update on public.inhcld2 i_2
-> Append
-> Seq Scan on public.inhcld1 i_1
- Output: (SubPlan 1).col1, (SubPlan 1).col2, (rescan SubPlan 1), i_1.tableoid, i_1.ctid
- SubPlan 1
+ Output: (multiexpr_1).col1, (multiexpr_1).col2, (rescan multiexpr_1), i_1.tableoid, i_1.ctid
+ SubPlan multiexpr_1
-> Limit
Output: (i_1.f1), (((i_1.f2)::text || '-'::text))
-> Seq Scan on public.int4_tbl
Output: i_1.f1, ((i_1.f2)::text || '-'::text)
-> Seq Scan on public.inhcld2 i_2
- Output: (SubPlan 1).col1, (SubPlan 1).col2, (rescan SubPlan 1), i_2.tableoid, i_2.ctid
+ Output: (multiexpr_1).col1, (multiexpr_1).col2, (rescan multiexpr_1), i_2.tableoid, i_2.ctid
(13 rows)
update inhpar i set (f1, f2) = (select i.f1, i.f2 || '-' from int4_tbl limit 1);
------------------------------------------------------------------------------------------------
Result
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan using parted_minmax1i on parted_minmax1 parted_minmax
Index Cond: ((a IS NOT NULL) AND (b = '12345'::text))
- InitPlan 2
+ InitPlan minmax_1
-> Limit
-> Index Only Scan Backward using parted_minmax1i on parted_minmax1 parted_minmax_1
Index Cond: ((a IS NOT NULL) AND (b = '12345'::text))
Insert on insertconflicttest
Conflict Resolution: UPDATE
Conflict Arbiter Indexes: op_index_key, collation_index_key, both_index_key
- Conflict Filter: EXISTS(SubPlan 1)
+ Conflict Filter: EXISTS(exists_1)
-> Result
- SubPlan 1
+ SubPlan exists_1
-> Index Only Scan using both_index_expr_key on insertconflicttest ii
Index Cond: (key = excluded.key)
(8 rows)
Sort
Sort Key: t1.unique1
-> Hash Join
- Hash Cond: ((t1.two = t2.two) AND (t1.unique1 = (SubPlan 2)))
+ Hash Cond: ((t1.two = t2.two) AND (t1.unique1 = (expr_1)))
-> Bitmap Heap Scan on tenk1 t1
Recheck Cond: (unique1 < 10)
-> Bitmap Index Scan on tenk1_unique1
Recheck Cond: (unique1 < 10)
-> Bitmap Index Scan on tenk1_unique1
Index Cond: (unique1 < 10)
- SubPlan 2
+ SubPlan expr_1
-> Result
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Only Scan using tenk1_unique1 on tenk1
Index Cond: ((unique1 IS NOT NULL) AND (unique1 = t2.unique1))
explain (costs off)
select a.* from tenk1 a
where unique1 not in (select unique2 from tenk1 b);
- QUERY PLAN
------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------
Seq Scan on tenk1 a
- Filter: (NOT (ANY (unique1 = (hashed SubPlan 1).col1)))
- SubPlan 1
+ Filter: (NOT (ANY (unique1 = (hashed any_1).col1)))
+ SubPlan any_1
-> Index Only Scan using tenk1_unique2 on tenk1 b
(4 rows)
Sort Key: t1.q1, t1.q2
-> Hash Left Join
Hash Cond: (t1.q2 = t2.q1)
- Filter: (1 = (SubPlan 1))
+ Filter: (1 = (expr_1))
-> Seq Scan on int8_tbl t1
-> Hash
-> Seq Scan on int8_tbl t2
- SubPlan 1
+ SubPlan expr_1
-> Limit
-> Result
One-Time Filter: ((42) IS NOT NULL)
right join (select false as z) ss3 on true,
lateral (select i8.q2 as q2l where x limit 1) ss4
where i8.q2 = 123;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------
Nested Loop
- Output: i8.q1, i8.q2, (InitPlan 1).col1, false, (i8.q2)
- InitPlan 1
+ Output: i8.q1, i8.q2, (expr_1).col1, false, (i8.q2)
+ InitPlan expr_1
-> Result
Output: true
- InitPlan 2
+ InitPlan expr_2
-> Result
Output: true
-> Seq Scan on public.int4_tbl i4
-> Nested Loop
Output: i8.q1, i8.q2, (i8.q2)
-> Subquery Scan on ss1
- Output: ss1.y, (InitPlan 1).col1
+ Output: ss1.y, (expr_1).col1
-> Limit
Output: NULL::integer
-> Result
Output: (i8.q2)
-> Result
Output: i8.q2
- One-Time Filter: ((InitPlan 1).col1)
+ One-Time Filter: ((expr_1).col1)
(29 rows)
explain (verbose, costs off)
right join (select false as z) ss3 on true,
lateral (select i8.q2 as q2l where x limit 1) ss4
where i8.q2 = 123;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------
Nested Loop
- Output: i8.q1, i8.q2, (InitPlan 1).col1, false, (i8.q2)
- InitPlan 1
+ Output: i8.q1, i8.q2, (expr_1).col1, false, (i8.q2)
+ InitPlan expr_1
-> Result
Output: true
- InitPlan 2
+ InitPlan expr_2
-> Result
Output: true
-> Limit
-> Nested Loop
Output: i8.q1, i8.q2, (i8.q2)
-> Seq Scan on public.int4_tbl i4
- Output: i4.f1, (InitPlan 1).col1
+ Output: i4.f1, (expr_1).col1
Filter: (i4.f1 = 0)
-> Nested Loop
Output: i8.q1, i8.q2, (i8.q2)
Output: (i8.q2)
-> Result
Output: i8.q2
- One-Time Filter: ((InitPlan 1).col1)
+ One-Time Filter: ((expr_1).col1)
(27 rows)
-- Test proper handling of appendrel PHVs during useless-RTE removal
select a.unique1, b.unique2
from onek a left join onek b on a.unique1 = b.unique2
where (b.unique2, random() > 0) = any (select q1, random() > 0 from int8_tbl c where c.q1 < b.unique1);
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------
Hash Join
Hash Cond: (b.unique2 = a.unique1)
-> Seq Scan on onek b
- Filter: (ANY ((unique2 = (SubPlan 1).col1) AND ((random() > '0'::double precision) = (SubPlan 1).col2)))
- SubPlan 1
+ Filter: (ANY ((unique2 = (any_1).col1) AND ((random() > '0'::double precision) = (any_1).col2)))
+ SubPlan any_1
-> Seq Scan on int8_tbl c
Filter: (q1 < b.unique1)
-> Hash
QUERY PLAN
---------------------------------------------------------------------
Seq Scan on int4_tbl x0
- SubPlan 1
+ SubPlan exists_1
-> Nested Loop Left Join
Join Filter: (t2.q2 = t4.q2)
-> Nested Loop Left Join
------------------------------------------
Seq Scan on sj t2
Filter: (a IS NOT NULL)
- SubPlan 1
+ SubPlan expr_1
-> Result
One-Time Filter: (t2.a = t2.a)
-> Seq Scan on sj
where q2 = (select greatest(t1.q1,t2.q2))
and (select v.id=0)) offset 0) ss2) ss
where t1.q1 = ss.q2) ss0;
- QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------------------
Nested Loop
Output: "*VALUES*".column1, t1.q1, t1.q2, ss2.q1, ss2.q2
-> Seq Scan on public.int8_tbl t1
Filter: (t1.q1 = ss2.q2)
-> Seq Scan on public.int8_tbl t2
Output: t2.q1, t2.q2
- Filter: (ANY ((t2.q1 = (SubPlan 3).col1) AND ((random() > '0'::double precision) = (SubPlan 3).col2)))
- SubPlan 3
+ Filter: (ANY ((t2.q1 = (any_1).col1) AND ((random() > '0'::double precision) = (any_1).col2)))
+ SubPlan any_1
-> Result
Output: t3.q2, (random() > '0'::double precision)
- One-Time Filter: (InitPlan 2).col1
- InitPlan 1
+ One-Time Filter: (expr_2).col1
+ InitPlan expr_1
-> Result
Output: GREATEST(t1.q1, t2.q2)
- InitPlan 2
+ InitPlan expr_2
-> Result
Output: ("*VALUES*".column1 = 0)
-> Seq Scan on public.int8_tbl t3
Output: t3.q1, t3.q2
- Filter: (t3.q2 = (InitPlan 1).col1)
+ Filter: (t3.q2 = (expr_1).col1)
(27 rows)
select * from (values (0), (1)) v(id),
QUERY PLAN
-----------------------------------------------------------
Nested Loop Left Join
- Join Filter: (ANY (t1.a = (SubPlan 1).col1))
+ Join Filter: (ANY (t1.a = (any_1).col1))
-> Bitmap Heap Scan on rescan_bhs t1
-> Bitmap Index Scan on rescan_bhs_a_idx
-> Materialize
-> Bitmap Heap Scan on rescan_bhs t2
-> Bitmap Index Scan on rescan_bhs_a_idx
- SubPlan 1
+ SubPlan any_1
-> Result
One-Time Filter: (t2.a > 1)
-> Bitmap Heap Scan on rescan_bhs t3
------------------------------------------------------------------------------------------------
Hash Join
Output: hjtest_1.a, hjtest_2.a, (hjtest_1.tableoid)::regclass, (hjtest_2.tableoid)::regclass
- Hash Cond: ((hjtest_1.id = (SubPlan 1)) AND ((SubPlan 2) = (SubPlan 3)))
+ Hash Cond: ((hjtest_1.id = (expr_1)) AND ((expr_2) = (expr_3)))
Join Filter: (hjtest_1.a <> hjtest_2.b)
-> Seq Scan on public.hjtest_1
Output: hjtest_1.a, hjtest_1.tableoid, hjtest_1.id, hjtest_1.b
- Filter: ((SubPlan 4) < 50)
- SubPlan 4
+ Filter: ((expr_4) < 50)
+ SubPlan expr_4
-> Result
Output: (hjtest_1.b * 5)
-> Hash
Output: hjtest_2.a, hjtest_2.tableoid, hjtest_2.id, hjtest_2.c, hjtest_2.b
-> Seq Scan on public.hjtest_2
Output: hjtest_2.a, hjtest_2.tableoid, hjtest_2.id, hjtest_2.c, hjtest_2.b
- Filter: ((SubPlan 5) < 55)
- SubPlan 5
+ Filter: ((expr_5) < 55)
+ SubPlan expr_5
-> Result
Output: (hjtest_2.c * 5)
- SubPlan 1
+ SubPlan expr_1
-> Result
Output: 1
One-Time Filter: (hjtest_2.id = 1)
- SubPlan 3
+ SubPlan expr_3
-> Result
Output: (hjtest_2.c * 5)
- SubPlan 2
+ SubPlan expr_2
-> Result
Output: (hjtest_1.b * 5)
(28 rows)
------------------------------------------------------------------------------------------------
Hash Join
Output: hjtest_1.a, hjtest_2.a, (hjtest_1.tableoid)::regclass, (hjtest_2.tableoid)::regclass
- Hash Cond: (((SubPlan 1) = hjtest_1.id) AND ((SubPlan 3) = (SubPlan 2)))
+ Hash Cond: (((expr_1) = hjtest_1.id) AND ((expr_3) = (expr_2)))
Join Filter: (hjtest_1.a <> hjtest_2.b)
-> Seq Scan on public.hjtest_2
Output: hjtest_2.a, hjtest_2.tableoid, hjtest_2.id, hjtest_2.c, hjtest_2.b
- Filter: ((SubPlan 5) < 55)
- SubPlan 5
+ Filter: ((expr_5) < 55)
+ SubPlan expr_5
-> Result
Output: (hjtest_2.c * 5)
-> Hash
Output: hjtest_1.a, hjtest_1.tableoid, hjtest_1.id, hjtest_1.b
-> Seq Scan on public.hjtest_1
Output: hjtest_1.a, hjtest_1.tableoid, hjtest_1.id, hjtest_1.b
- Filter: ((SubPlan 4) < 50)
- SubPlan 4
+ Filter: ((expr_4) < 50)
+ SubPlan expr_4
-> Result
Output: (hjtest_1.b * 5)
- SubPlan 2
+ SubPlan expr_2
-> Result
Output: (hjtest_1.b * 5)
- SubPlan 1
+ SubPlan expr_1
-> Result
Output: 1
One-Time Filter: (hjtest_2.id = 1)
- SubPlan 3
+ SubPlan expr_3
-> Result
Output: (hjtest_2.c * 5)
(28 rows)
----------------------------------------------------------------
Index Scan using tenk1_unique1 on tenk1 t0
Index Cond: (unique1 < 3)
- Filter: EXISTS(SubPlan 1)
- SubPlan 1
+ Filter: EXISTS(exists_1)
+ SubPlan exists_1
-> Nested Loop
-> Index Scan using tenk1_hundred on tenk1 t2
Filter: (t0.two <> four)
-> Hash Join
Output: t.ctid, s.a, s.b, s.c, s.d, s.ctid
Hash Cond: (t.a = s.a)
- Join Filter: (t.b < (SubPlan 1))
+ Join Filter: (t.b < (expr_1))
-> Seq Scan on public.tgt t
Output: t.ctid, t.a, t.b
-> Hash
Output: s.a, s.b, s.c, s.d, s.ctid
-> Seq Scan on public.src s
Output: s.a, s.b, s.c, s.d, s.ctid
- SubPlan 1
+ SubPlan expr_1
-> Aggregate
Output: count(*)
-> Seq Scan on public.ref r
Output: r.ab, r.cd
Filter: ((r.ab = (s.a + s.b)) AND (r.cd = (s.c - s.d)))
- SubPlan 4
+ SubPlan expr_3
-> Aggregate
Output: count(*)
-> Seq Scan on public.ref r_2
Output: r_2.ab, r_2.cd
Filter: ((r_2.ab = (s.a + s.b)) AND (r_2.cd = (s.c - s.d)))
- SubPlan 3
+ SubPlan multiexpr_1
-> Result
- Output: s.b, (InitPlan 2).col1
- InitPlan 2
+ Output: s.b, (expr_2).col1
+ InitPlan expr_2
-> Aggregate
Output: count(*)
-> Seq Scan on public.ref r_1
-> Seq Scan on int4_tbl touter
-> Append
-> Index Only Scan using asptab0_pkey on asptab0 asptab_1
- Index Cond: (id > (EXISTS(SubPlan 3))::integer)
- SubPlan 4
+ Index Cond: (id > (EXISTS(exists_3))::integer)
+ SubPlan exists_4
-> Seq Scan on int4_tbl tinner_2
-> Index Only Scan using asptab1_pkey on asptab1 asptab_2
- Index Cond: (id > (EXISTS(SubPlan 3))::integer)
- SubPlan 3
+ Index Cond: (id > (EXISTS(exists_3))::integer)
+ SubPlan exists_3
-> Seq Scan on int4_tbl tinner_1
Filter: (f1 = touter.f1)
- SubPlan 2
+ SubPlan exists_2
-> Seq Scan on int4_tbl tinner
(14 rows)
prepare ab_q2 (int, int) as
select a from ab where a between $1 and $2 and b < (select 3);
explain (analyze, costs off, summary off, timing off, buffers off) execute ab_q2 (2, 2);
- QUERY PLAN
------------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------
Append (actual rows=0.00 loops=1)
Subplans Removed: 6
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Seq Scan on ab_a2_b1 ab_1 (actual rows=0.00 loops=1)
- Filter: ((a >= $1) AND (a <= $2) AND (b < (InitPlan 1).col1))
+ Filter: ((a >= $1) AND (a <= $2) AND (b < (expr_1).col1))
-> Seq Scan on ab_a2_b2 ab_2 (actual rows=0.00 loops=1)
- Filter: ((a >= $1) AND (a <= $2) AND (b < (InitPlan 1).col1))
+ Filter: ((a >= $1) AND (a <= $2) AND (b < (expr_1).col1))
-> Seq Scan on ab_a2_b3 ab_3 (never executed)
- Filter: ((a >= $1) AND (a <= $2) AND (b < (InitPlan 1).col1))
+ Filter: ((a >= $1) AND (a <= $2) AND (b < (expr_1).col1))
(10 rows)
-- As above, but swap the PARAM_EXEC Param to the first partition level
prepare ab_q3 (int, int) as
select a from ab where b between $1 and $2 and a < (select 3);
explain (analyze, costs off, summary off, timing off, buffers off) execute ab_q3 (2, 2);
- QUERY PLAN
------------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------
Append (actual rows=0.00 loops=1)
Subplans Removed: 6
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Seq Scan on ab_a1_b2 ab_1 (actual rows=0.00 loops=1)
- Filter: ((b >= $1) AND (b <= $2) AND (a < (InitPlan 1).col1))
+ Filter: ((b >= $1) AND (b <= $2) AND (a < (expr_1).col1))
-> Seq Scan on ab_a2_b2 ab_2 (actual rows=0.00 loops=1)
- Filter: ((b >= $1) AND (b <= $2) AND (a < (InitPlan 1).col1))
+ Filter: ((b >= $1) AND (b <= $2) AND (a < (expr_1).col1))
-> Seq Scan on ab_a3_b2 ab_3 (never executed)
- Filter: ((b >= $1) AND (b <= $2) AND (a < (InitPlan 1).col1))
+ Filter: ((b >= $1) AND (b <= $2) AND (a < (expr_1).col1))
(10 rows)
--
-- Test Parallel Append with PARAM_EXEC Params
select explain_parallel_append('select count(*) from ab where (a = (select 1) or a = (select 3)) and b = 2');
- explain_parallel_append
-------------------------------------------------------------------------------------------------
+ explain_parallel_append
+----------------------------------------------------------------------------------------
Aggregate (actual rows=N loops=N)
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=N loops=N)
- InitPlan 2
+ InitPlan expr_2
-> Result (actual rows=N loops=N)
-> Gather (actual rows=N loops=N)
Workers Planned: 2
Workers Launched: N
-> Parallel Append (actual rows=N loops=N)
-> Parallel Seq Scan on ab_a1_b2 ab_1 (actual rows=N loops=N)
- Filter: ((b = 2) AND ((a = (InitPlan 1).col1) OR (a = (InitPlan 2).col1)))
+ Filter: ((b = 2) AND ((a = (expr_1).col1) OR (a = (expr_2).col1)))
-> Parallel Seq Scan on ab_a2_b2 ab_2 (never executed)
- Filter: ((b = 2) AND ((a = (InitPlan 1).col1) OR (a = (InitPlan 2).col1)))
+ Filter: ((b = 2) AND ((a = (expr_1).col1) OR (a = (expr_2).col1)))
-> Parallel Seq Scan on ab_a3_b2 ab_3 (actual rows=N loops=N)
- Filter: ((b = 2) AND ((a = (InitPlan 1).col1) OR (a = (InitPlan 2).col1)))
+ Filter: ((b = 2) AND ((a = (expr_1).col1) OR (a = (expr_2).col1)))
(15 rows)
-- Test pruning during parallel nested loop query
QUERY PLAN
----------------------------------------------------------------------------
Append (actual rows=0.00 loops=1)
- InitPlan 1
+ InitPlan expr_1
-> Aggregate (actual rows=1.00 loops=1)
-> Seq Scan on lprt_a (actual rows=102.00 loops=1)
- InitPlan 2
+ InitPlan expr_2
-> Aggregate (actual rows=1.00 loops=1)
-> Seq Scan on lprt_a lprt_a_1 (actual rows=102.00 loops=1)
-> Bitmap Heap Scan on ab_a1_b1 ab_1 (never executed)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (expr_1).col1)
+ Filter: (b = (expr_2).col1)
-> Bitmap Index Scan on ab_a1_b1_a_idx (never executed)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (expr_1).col1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a1_b2 ab_2 (never executed)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (expr_1).col1)
+ Filter: (b = (expr_2).col1)
-> Bitmap Index Scan on ab_a1_b2_a_idx (never executed)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (expr_1).col1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a1_b3 ab_3 (never executed)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (expr_1).col1)
+ Filter: (b = (expr_2).col1)
-> Bitmap Index Scan on ab_a1_b3_a_idx (never executed)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (expr_1).col1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a2_b1 ab_4 (never executed)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (expr_1).col1)
+ Filter: (b = (expr_2).col1)
-> Bitmap Index Scan on ab_a2_b1_a_idx (never executed)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (expr_1).col1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a2_b2 ab_5 (never executed)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (expr_1).col1)
+ Filter: (b = (expr_2).col1)
-> Bitmap Index Scan on ab_a2_b2_a_idx (never executed)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (expr_1).col1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a2_b3 ab_6 (never executed)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (expr_1).col1)
+ Filter: (b = (expr_2).col1)
-> Bitmap Index Scan on ab_a2_b3_a_idx (never executed)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (expr_1).col1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a3_b1 ab_7 (never executed)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (expr_1).col1)
+ Filter: (b = (expr_2).col1)
-> Bitmap Index Scan on ab_a3_b1_a_idx (never executed)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (expr_1).col1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a3_b2 ab_8 (actual rows=0.00 loops=1)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (expr_1).col1)
+ Filter: (b = (expr_2).col1)
-> Bitmap Index Scan on ab_a3_b2_a_idx (actual rows=0.00 loops=1)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (expr_1).col1)
Index Searches: 1
-> Bitmap Heap Scan on ab_a3_b3 ab_9 (never executed)
- Recheck Cond: (a = (InitPlan 1).col1)
- Filter: (b = (InitPlan 2).col1)
+ Recheck Cond: (a = (expr_1).col1)
+ Filter: (b = (expr_2).col1)
-> Bitmap Index Scan on ab_a3_b3_a_idx (never executed)
- Index Cond: (a = (InitPlan 1).col1)
+ Index Cond: (a = (expr_1).col1)
Index Searches: 0
(61 rows)
QUERY PLAN
----------------------------------------------------------------------------------
Append (actual rows=0.00 loops=1)
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Append (actual rows=0.00 loops=1)
-> Bitmap Heap Scan on ab_a1_b1 ab_11 (actual rows=0.00 loops=1)
Recheck Cond: (a = 1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = 1)
Index Searches: 1
-> Bitmap Heap Scan on ab_a1_b2 ab_12 (never executed)
Recheck Cond: (a = 1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Bitmap Index Scan on ab_a1_b2_a_idx (never executed)
Index Cond: (a = 1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a1_b3 ab_13 (never executed)
Recheck Cond: (a = 1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Bitmap Index Scan on ab_a1_b3_a_idx (never executed)
Index Cond: (a = 1)
Index Searches: 0
-> Seq Scan on ab_a1_b1 ab_1 (actual rows=0.00 loops=1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a1_b2 ab_2 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a1_b3 ab_3 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a2_b1 ab_4 (actual rows=0.00 loops=1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a2_b2 ab_5 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a2_b3 ab_6 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a3_b1 ab_7 (actual rows=0.00 loops=1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a3_b2 ab_8 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a3_b3 ab_9 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
(40 rows)
-- A case containing a UNION ALL with a non-partitioned child.
QUERY PLAN
----------------------------------------------------------------------------------
Append (actual rows=0.00 loops=1)
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Append (actual rows=0.00 loops=1)
-> Bitmap Heap Scan on ab_a1_b1 ab_11 (actual rows=0.00 loops=1)
Recheck Cond: (a = 1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0.00 loops=1)
Index Cond: (a = 1)
Index Searches: 1
-> Bitmap Heap Scan on ab_a1_b2 ab_12 (never executed)
Recheck Cond: (a = 1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Bitmap Index Scan on ab_a1_b2_a_idx (never executed)
Index Cond: (a = 1)
Index Searches: 0
-> Bitmap Heap Scan on ab_a1_b3 ab_13 (never executed)
Recheck Cond: (a = 1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Bitmap Index Scan on ab_a1_b3_a_idx (never executed)
Index Cond: (a = 1)
Index Searches: 0
-> Result (actual rows=0.00 loops=1)
- One-Time Filter: (5 = (InitPlan 1).col1)
+ One-Time Filter: (5 = (expr_1).col1)
-> Seq Scan on ab_a1_b1 ab_1 (actual rows=0.00 loops=1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a1_b2 ab_2 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a1_b3 ab_3 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a2_b1 ab_4 (actual rows=0.00 loops=1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a2_b2 ab_5 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a2_b3 ab_6 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a3_b1 ab_7 (actual rows=0.00 loops=1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a3_b2 ab_8 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a3_b3 ab_9 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
(42 rows)
-- Another UNION ALL test, but containing a mix of exec init and exec run-time pruning.
) ab where a = $1 and b = (select -10);
-- Ensure the xy_1 subplan is not pruned.
explain (analyze, costs off, summary off, timing off, buffers off) execute ab_q6(1);
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------
Append (actual rows=0.00 loops=1)
Subplans Removed: 12
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Seq Scan on ab_a1_b1 ab_1 (never executed)
- Filter: ((a = $1) AND (b = (InitPlan 1).col1))
+ Filter: ((a = $1) AND (b = (expr_1).col1))
-> Seq Scan on ab_a1_b2 ab_2 (never executed)
- Filter: ((a = $1) AND (b = (InitPlan 1).col1))
+ Filter: ((a = $1) AND (b = (expr_1).col1))
-> Seq Scan on ab_a1_b3 ab_3 (never executed)
- Filter: ((a = $1) AND (b = (InitPlan 1).col1))
+ Filter: ((a = $1) AND (b = (expr_1).col1))
-> Seq Scan on xy_1 (actual rows=0.00 loops=1)
- Filter: ((x = $1) AND (y = (InitPlan 1).col1))
+ Filter: ((x = $1) AND (y = (expr_1).col1))
Rows Removed by Filter: 1
-> Seq Scan on ab_a1_b1 ab_4 (never executed)
- Filter: ((a = $1) AND (b = (InitPlan 1).col1))
+ Filter: ((a = $1) AND (b = (expr_1).col1))
-> Seq Scan on ab_a1_b2 ab_5 (never executed)
- Filter: ((a = $1) AND (b = (InitPlan 1).col1))
+ Filter: ((a = $1) AND (b = (expr_1).col1))
-> Seq Scan on ab_a1_b3 ab_6 (never executed)
- Filter: ((a = $1) AND (b = (InitPlan 1).col1))
+ Filter: ((a = $1) AND (b = (expr_1).col1))
(19 rows)
-- Ensure we see just the xy_1 row.
Update on ab_a1_b1 ab_a1_1
Update on ab_a1_b2 ab_a1_2
Update on ab_a1_b3 ab_a1_3
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Nested Loop (actual rows=3.00 loops=1)
-> Append (actual rows=3.00 loops=1)
Storage: Memory Maximum Storage: NkB
-> Append (actual rows=1.00 loops=1)
-> Seq Scan on ab_a2_b1 ab_a2_1 (actual rows=1.00 loops=1)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a2_b2 ab_a2_2 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
-> Seq Scan on ab_a2_b3 ab_a2_3 (never executed)
- Filter: (b = (InitPlan 1).col1)
+ Filter: (b = (expr_1).col1)
(20 rows)
select tableoid::regclass, * from ab;
QUERY PLAN
------------------------------------------------------
Append (actual rows=0.00 loops=1)
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Seq Scan on listp_1_1 listp_1 (never executed)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (expr_1).col1)
-> Seq Scan on listp_2_1 listp_2 (never executed)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (expr_1).col1)
(7 rows)
drop table listp;
select * from mc3p where a = $1 and abs(b) < (select 3);
explain (analyze, costs off, summary off, timing off, buffers off)
execute ps1(1);
- QUERY PLAN
--------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------
Append (actual rows=1.00 loops=1)
Subplans Removed: 2
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Seq Scan on mc3p1 mc3p_1 (actual rows=1.00 loops=1)
- Filter: ((a = $1) AND (abs(b) < (InitPlan 1).col1))
+ Filter: ((a = $1) AND (abs(b) < (expr_1).col1))
(6 rows)
deallocate ps1;
select * from mc3p where a <= $1 and abs(b) < (select 3);
explain (analyze, costs off, summary off, timing off, buffers off)
execute ps2(1);
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------
Append (actual rows=2.00 loops=1)
Subplans Removed: 1
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
-> Seq Scan on mc3p0 mc3p_1 (actual rows=1.00 loops=1)
- Filter: ((a <= $1) AND (abs(b) < (InitPlan 1).col1))
+ Filter: ((a <= $1) AND (abs(b) < (expr_1).col1))
-> Seq Scan on mc3p1 mc3p_2 (actual rows=1.00 loops=1)
- Filter: ((a <= $1) AND (abs(b) < (InitPlan 1).col1))
+ Filter: ((a <= $1) AND (abs(b) < (expr_1).col1))
(8 rows)
deallocate ps2;
QUERY PLAN
--------------------------------------------------------------
Append (actual rows=0.00 loops=1)
- InitPlan 1
+ InitPlan expr_1
-> Seq Scan on boolvalues (actual rows=1.00 loops=1)
Filter: value
Rows Removed by Filter: 1
-> Seq Scan on boolp_f boolp_1 (never executed)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (expr_1).col1)
-> Seq Scan on boolp_t boolp_2 (actual rows=0.00 loops=1)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (expr_1).col1)
(9 rows)
explain (analyze, costs off, summary off, timing off, buffers off)
QUERY PLAN
--------------------------------------------------------------
Append (actual rows=0.00 loops=1)
- InitPlan 1
+ InitPlan expr_1
-> Seq Scan on boolvalues (actual rows=1.00 loops=1)
Filter: (NOT value)
Rows Removed by Filter: 1
-> Seq Scan on boolp_f boolp_1 (actual rows=0.00 loops=1)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (expr_1).col1)
-> Seq Scan on boolp_t boolp_2 (never executed)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (expr_1).col1)
(9 rows)
drop table boolp;
--------------------------------------------------------------------------------------------------
Merge Append (actual rows=20.00 loops=1)
Sort Key: ma_test.b
- InitPlan 2
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit (actual rows=1.00 loops=1)
-> Index Scan using ma_test_p2_b_idx on ma_test_p2 (actual rows=1.00 loops=1)
Index Cond: (b IS NOT NULL)
Index Searches: 1
-> Index Scan using ma_test_p1_b_idx on ma_test_p1 ma_test_1 (never executed)
- Filter: (a >= (InitPlan 2).col1)
+ Filter: (a >= (expr_1).col1)
Index Searches: 0
-> Index Scan using ma_test_p2_b_idx on ma_test_p2 ma_test_2 (actual rows=10.00 loops=1)
- Filter: (a >= (InitPlan 2).col1)
+ Filter: (a >= (expr_1).col1)
Index Searches: 1
-> Index Scan using ma_test_p3_b_idx on ma_test_p3 ma_test_3 (actual rows=10.00 loops=1)
- Filter: (a >= (InitPlan 2).col1)
+ Filter: (a >= (expr_1).col1)
Index Searches: 1
(19 rows)
select 1, 1, 1
) s(a, b, c)
where s.a = 1 and s.b = 1 and s.c = (select 1);
- QUERY PLAN
--------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Append
- InitPlan 1
+ InitPlan expr_1
-> Result
-> Seq Scan on p1 p
- Filter: ((a = 1) AND (b = 1) AND (c = (InitPlan 1).col1))
+ Filter: ((a = 1) AND (b = 1) AND (c = (expr_1).col1))
-> Seq Scan on q111 q1
- Filter: ((a = 1) AND (b = 1) AND (c = (InitPlan 1).col1))
+ Filter: ((a = 1) AND (b = 1) AND (c = (expr_1).col1))
-> Result
- One-Time Filter: (1 = (InitPlan 1).col1)
+ One-Time Filter: (1 = (expr_1).col1)
(9 rows)
select *
) s(a, b, c)
where s.a = $1 and s.b = $2 and s.c = (select 1);
explain (costs off) execute q (1, 1);
- QUERY PLAN
-------------------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------------------
Append
Subplans Removed: 1
- InitPlan 1
+ InitPlan expr_1
-> Result
-> Seq Scan on p1 p
- Filter: ((a = $1) AND (b = $2) AND (c = (InitPlan 1).col1))
+ Filter: ((a = $1) AND (b = $2) AND (c = (expr_1).col1))
-> Seq Scan on q111 q1
- Filter: ((a = $1) AND (b = $2) AND (c = (InitPlan 1).col1))
+ Filter: ((a = $1) AND (b = $2) AND (c = (expr_1).col1))
-> Result
- One-Time Filter: ((1 = $1) AND (1 = $2) AND (1 = (InitPlan 1).col1))
+ One-Time Filter: ((1 = $1) AND (1 = $2) AND (1 = (expr_1).col1))
(10 rows)
execute q (1, 1);
QUERY PLAN
-----------------------------------------------------
Seq Scan on listp1 listp (actual rows=0.00 loops=1)
- Filter: ((b <> 10) AND (a = (InitPlan 1).col1))
- InitPlan 1
+ Filter: ((b <> 10) AND (a = (expr_1).col1))
+ InitPlan expr_1
-> Result (never executed)
(4 rows)
Gather (actual rows=N loops=N)
Workers Planned: 2
Workers Launched: N
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=N loops=N)
-> Parallel Append (actual rows=N loops=N)
-> Seq Scan on listp_12_1 listp_1 (actual rows=N loops=N)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (expr_1).col1)
-> Parallel Seq Scan on listp_12_2 listp_2 (never executed)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (expr_1).col1)
(10 rows)
-- Like the above but throw some more complexity at the planner by adding
Workers Launched: N
-> Parallel Append (actual rows=N loops=N)
-> Parallel Append (actual rows=N loops=N)
- InitPlan 2
+ InitPlan expr_2
-> Result (actual rows=N loops=N)
-> Seq Scan on listp_12_1 listp_1 (never executed)
- Filter: (a = (InitPlan 2).col1)
+ Filter: (a = (expr_2).col1)
-> Parallel Seq Scan on listp_12_2 listp_2 (actual rows=N loops=N)
- Filter: (a = (InitPlan 2).col1)
+ Filter: (a = (expr_2).col1)
-> Parallel Append (actual rows=N loops=N)
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=N loops=N)
-> Seq Scan on listp_12_1 listp_4 (actual rows=N loops=N)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (expr_1).col1)
-> Parallel Seq Scan on listp_12_2 listp_5 (never executed)
- Filter: (a = (InitPlan 1).col1)
+ Filter: (a = (expr_1).col1)
(18 rows)
drop table listp;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------
Append (actual rows=0.00 loops=1)
- InitPlan 1
+ InitPlan expr_1
-> Result (actual rows=1.00 loops=1)
- InitPlan 2
+ InitPlan expr_2
-> Result (actual rows=1.00 loops=1)
-> Merge Append (actual rows=0.00 loops=1)
Sort Key: rangep_2.a
-> Index Scan using rangep_0_to_100_1_a_idx on rangep_0_to_100_1 rangep_2 (actual rows=0.00 loops=1)
- Filter: (b = ANY (ARRAY[(InitPlan 1).col1, (InitPlan 2).col1]))
+ Filter: (b = ANY (ARRAY[(expr_1).col1, (expr_2).col1]))
Index Searches: 1
-> Index Scan using rangep_0_to_100_2_a_idx on rangep_0_to_100_2 rangep_3 (actual rows=0.00 loops=1)
- Filter: (b = ANY (ARRAY[(InitPlan 1).col1, (InitPlan 2).col1]))
+ Filter: (b = ANY (ARRAY[(expr_1).col1, (expr_2).col1]))
Index Searches: 1
-> Index Scan using rangep_0_to_100_3_a_idx on rangep_0_to_100_3 rangep_4 (never executed)
- Filter: (b = ANY (ARRAY[(InitPlan 1).col1, (InitPlan 2).col1]))
+ Filter: (b = ANY (ARRAY[(expr_1).col1, (expr_2).col1]))
Index Searches: 0
-> Index Scan using rangep_100_to_200_a_idx on rangep_100_to_200 rangep_5 (actual rows=0.00 loops=1)
- Filter: (b = ANY (ARRAY[(InitPlan 1).col1, (InitPlan 2).col1]))
+ Filter: (b = ANY (ARRAY[(expr_1).col1, (expr_2).col1]))
Index Searches: 1
(19 rows)
-- Check handling of non-backwards-scan-capable plans with scroll cursors
begin;
explain (costs off) declare c1 cursor for select (select 42) as x;
- QUERY PLAN
-----------------
+ QUERY PLAN
+-------------------
Result
- InitPlan 1
+ InitPlan expr_1
-> Result
(3 rows)
explain (costs off) declare c1 scroll cursor for select (select 42) as x;
- QUERY PLAN
-----------------
+ QUERY PLAN
+-------------------
Materialize
- InitPlan 1
+ InitPlan expr_1
-> Result
-> Result
(4 rows)
QUERY PLAN
---------------------------------------------------------
Nested Loop Left Join
- Join Filter: EXISTS(SubPlan 1)
+ Join Filter: EXISTS(exists_1)
-> Seq Scan on pred_tab t1
-> Materialize
-> Seq Scan on pred_tab t2
- SubPlan 1
+ SubPlan exists_1
-> Nested Loop
-> Nested Loop
-> Nested Loop
LEFT JOIN pred_tab t2 ON EXISTS
(SELECT 1 FROM pred_tab t3, pred_tab t4, pred_tab t5, pred_tab t6
WHERE t1.a = t3.a AND t6.a IS NULL);
- QUERY PLAN
--------------------------------------
+ QUERY PLAN
+--------------------------------------------
Nested Loop Left Join
- Join Filter: (InitPlan 1).col1
- InitPlan 1
+ Join Filter: (exists_1).col1
+ InitPlan exists_1
-> Result
One-Time Filter: false
+ Replaces: Join on t3, t4, t5, t6
-> Seq Scan on pred_tab t1
-> Materialize
-> Seq Scan on pred_tab t2
-(8 rows)
+(9 rows)
DROP TABLE pred_tab;
-- Validate we handle IS NULL and IS NOT NULL quals correctly with inheritance
QUERY PLAN
---------------------------------------------------------------
Insert on pg_temp.foo
- Output: (SubPlan 1), (SubPlan 2)
+ Output: (expr_1), (expr_2)
-> Result
Output: 5, 'subquery test'::text, 42, '99'::bigint
- SubPlan 1
+ SubPlan expr_1
-> Aggregate
Output: max((old.f4 + x.x))
-> Function Scan on pg_catalog.generate_series x
Output: x.x
Function Call: generate_series(1, 10)
- SubPlan 2
+ SubPlan expr_2
-> Aggregate
Output: max((new.f4 + x_1.x))
-> Function Scan on pg_catalog.generate_series x_1
QUERY PLAN
---------------------------------------------------------------
Update on pg_temp.foo
- Output: (SubPlan 1), (SubPlan 2), (SubPlan 3)
+ Output: (expr_1), (expr_2), (expr_3)
Update on pg_temp.foo foo_1
-> Result
Output: '100'::bigint, foo_1.tableoid, foo_1.ctid
-> Seq Scan on pg_temp.foo foo_1
Output: foo_1.tableoid, foo_1.ctid
Filter: (foo_1.f1 = 5)
- SubPlan 1
+ SubPlan expr_1
-> Result
Output: (old.f4 = new.f4)
- SubPlan 2
+ SubPlan expr_2
-> Aggregate
Output: max((old.f4 + x.x))
-> Function Scan on pg_catalog.generate_series x
Output: x.x
Function Call: generate_series(1, 10)
- SubPlan 3
+ SubPlan expr_3
-> Aggregate
Output: max((new.f4 + x_1.x))
-> Function Scan on pg_catalog.generate_series x_1
QUERY PLAN
---------------------------------------------------------------
Delete on pg_temp.foo
- Output: (SubPlan 1), (SubPlan 2)
+ Output: (expr_1), (expr_2)
Delete on pg_temp.foo foo_1
-> Seq Scan on pg_temp.foo foo_1
Output: foo_1.tableoid, foo_1.ctid
Filter: (foo_1.f1 = 5)
- SubPlan 1
+ SubPlan expr_1
-> Aggregate
Output: max((old.f4 + x.x))
-> Function Scan on pg_catalog.generate_series x
Output: x.x
Function Call: generate_series(1, 10)
- SubPlan 2
+ SubPlan expr_2
-> Aggregate
Output: max((new.f4 + x_1.x))
-> Function Scan on pg_catalog.generate_series x_1
(5 rows)
EXPLAIN (COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle);
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
Seq Scan on document
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
- InitPlan 1
+ Filter: ((dlevel <= (expr_1).col1) AND f_leak(dtitle))
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
(5 rows)
EXPLAIN (COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle);
- QUERY PLAN
---------------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------
Hash Join
Hash Cond: (category.cid = document.cid)
- InitPlan 1
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
-> Seq Scan on category
-> Hash
-> Seq Scan on document
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (expr_1).col1) AND f_leak(dtitle))
(9 rows)
-- viewpoint from regress_rls_dave
(7 rows)
EXPLAIN (COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle);
- QUERY PLAN
--------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------
Seq Scan on document
- Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
- InitPlan 1
+ Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (expr_1).col1) AND f_leak(dtitle))
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
(5 rows)
EXPLAIN (COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle);
- QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------
Hash Join
Hash Cond: (category.cid = document.cid)
- InitPlan 1
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
-> Seq Scan on category
-> Hash
-> Seq Scan on document
- Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (expr_1).col1) AND f_leak(dtitle))
(9 rows)
-- 44 would technically fail for both p2r and p1r, but we should get an error
(4 rows)
EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
- QUERY PLAN
---------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------
Append
- InitPlan 1
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
-> Seq Scan on part_document_fiction part_document_1
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (expr_1).col1) AND f_leak(dtitle))
-> Seq Scan on part_document_satire part_document_2
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (expr_1).col1) AND f_leak(dtitle))
-> Seq Scan on part_document_nonfiction part_document_3
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (expr_1).col1) AND f_leak(dtitle))
(10 rows)
-- viewpoint from regress_rls_carol
(10 rows)
EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
- QUERY PLAN
---------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------
Append
- InitPlan 1
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
-> Seq Scan on part_document_fiction part_document_1
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (expr_1).col1) AND f_leak(dtitle))
-> Seq Scan on part_document_satire part_document_2
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (expr_1).col1) AND f_leak(dtitle))
-> Seq Scan on part_document_nonfiction part_document_3
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (expr_1).col1) AND f_leak(dtitle))
(10 rows)
-- viewpoint from regress_rls_dave
(4 rows)
EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
- QUERY PLAN
------------------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------------
Seq Scan on part_document_fiction part_document
- Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
- InitPlan 1
+ Filter: ((cid < 55) AND (dlevel <= (expr_1).col1) AND f_leak(dtitle))
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
(5 rows)
(4 rows)
EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
- QUERY PLAN
------------------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------------
Seq Scan on part_document_fiction part_document
- Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
- InitPlan 1
+ Filter: ((cid < 55) AND (dlevel <= (expr_1).col1) AND f_leak(dtitle))
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
(5 rows)
(11 rows)
EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
- QUERY PLAN
---------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------
Append
- InitPlan 1
+ InitPlan expr_1
-> Index Scan using uaccount_pkey on uaccount
Index Cond: (pguser = CURRENT_USER)
-> Seq Scan on part_document_fiction part_document_1
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (expr_1).col1) AND f_leak(dtitle))
-> Seq Scan on part_document_satire part_document_2
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (expr_1).col1) AND f_leak(dtitle))
-> Seq Scan on part_document_nonfiction part_document_3
- Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle))
+ Filter: ((dlevel <= (expr_1).col1) AND f_leak(dtitle))
(10 rows)
-- only owner can change policies
(1 row)
EXPLAIN (COSTS OFF) SELECT * FROM only s1 WHERE f_leak(b);
- QUERY PLAN
----------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------
Seq Scan on s1
- Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b))
- SubPlan 1
+ Filter: ((ANY (a = (hashed any_1).col1)) AND f_leak(b))
+ SubPlan any_1
-> Seq Scan on s2
Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text))
(5 rows)
(1 row)
EXPLAIN (COSTS OFF) SELECT * FROM s1 WHERE f_leak(b);
- QUERY PLAN
----------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------
Seq Scan on s1
- Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b))
- SubPlan 1
+ Filter: ((ANY (a = (hashed any_1).col1)) AND f_leak(b))
+ SubPlan any_1
-> Seq Scan on s2
Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text))
(5 rows)
-------------------------------------------------------------------------
Seq Scan on s2
Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text))
- SubPlan 2
+ SubPlan expr_1
-> Limit
-> Seq Scan on s1
- Filter: (ANY (a = (hashed SubPlan 1).col1))
- SubPlan 1
+ Filter: (ANY (a = (hashed any_1).col1))
+ SubPlan any_1
-> Seq Scan on s2 s2_1
Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text))
(9 rows)
(1 row)
EXPLAIN (COSTS OFF) SELECT * FROM rls_view;
- QUERY PLAN
----------------------------------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------------------------------
Seq Scan on z1
- Filter: ((NOT (ANY (a = (hashed SubPlan 1).col1))) AND ((a % 2) = 0) AND f_leak(b))
- SubPlan 1
+ Filter: ((NOT (ANY (a = (hashed any_1).col1))) AND ((a % 2) = 0) AND f_leak(b))
+ SubPlan any_1
-> Seq Scan on z1_blacklist
(4 rows)
(1 row)
EXPLAIN (COSTS OFF) SELECT * FROM rls_view;
- QUERY PLAN
----------------------------------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------------------------------
Seq Scan on z1
- Filter: ((NOT (ANY (a = (hashed SubPlan 1).col1))) AND ((a % 2) = 0) AND f_leak(b))
- SubPlan 1
+ Filter: ((NOT (ANY (a = (hashed any_1).col1))) AND ((a % 2) = 0) AND f_leak(b))
+ SubPlan any_1
-> Seq Scan on z1_blacklist
(4 rows)
(1 row)
EXPLAIN (COSTS OFF) SELECT * FROM rls_view;
- QUERY PLAN
----------------------------------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------------------------------
Seq Scan on z1
- Filter: ((NOT (ANY (a = (hashed SubPlan 1).col1))) AND ((a % 2) = 0) AND f_leak(b))
- SubPlan 1
+ Filter: ((NOT (ANY (a = (hashed any_1).col1))) AND ((a % 2) = 0) AND f_leak(b))
+ SubPlan any_1
-> Seq Scan on z1_blacklist
(4 rows)
(1 row)
EXPLAIN (COSTS OFF) SELECT * FROM rls_view;
- QUERY PLAN
----------------------------------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------------------------------
Seq Scan on z1
- Filter: ((NOT (ANY (a = (hashed SubPlan 1).col1))) AND ((a % 2) = 1) AND f_leak(b))
- SubPlan 1
+ Filter: ((NOT (ANY (a = (hashed any_1).col1))) AND ((a % 2) = 1) AND f_leak(b))
+ SubPlan any_1
-> Seq Scan on z1_blacklist
(4 rows)
select * from cte2 as t
where (select * from (select c as c1) s
where (select (c1).f1 > 0)) is not null;
- QUERY PLAN
-----------------------------------------------
+ QUERY PLAN
+--------------------------------------------
CTE Scan on cte
Output: cte.c
- Filter: ((SubPlan 3) IS NOT NULL)
+ Filter: ((expr_1) IS NOT NULL)
CTE cte
-> Result
Output: '(1,2)'::record
- SubPlan 3
+ SubPlan expr_1
-> Result
Output: cte.c
- One-Time Filter: (InitPlan 2).col1
- InitPlan 2
+ One-Time Filter: (expr_2).col1
+ InitPlan expr_2
-> Result
Output: ((cte.c).f1 > 0)
(13 rows)
-> Parallel Append
-> Parallel Seq Scan on part_pa_test_p1 pa2_1
-> Parallel Seq Scan on part_pa_test_p2 pa2_2
- SubPlan 2
+ SubPlan expr_1
-> Result
- SubPlan 1
+ SubPlan expr_2
-> Append
-> Seq Scan on part_pa_test_p1 pa1_1
Filter: (a = pa2.a)
explain (costs off)
select count(*) from tenk1 where (two, four) not in
(select hundred, thousand from tenk2 where thousand > 100);
- QUERY PLAN
-----------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------------------------------------------------
Finalize Aggregate
-> Gather
Workers Planned: 4
-> Partial Aggregate
-> Parallel Seq Scan on tenk1
- Filter: (NOT (ANY ((two = (hashed SubPlan 1).col1) AND (four = (hashed SubPlan 1).col2))))
- SubPlan 1
+ Filter: (NOT (ANY ((two = (hashed any_1).col1) AND (four = (hashed any_1).col2))))
+ SubPlan any_1
-> Seq Scan on tenk2
Filter: (thousand > 100)
(9 rows)
explain (costs off)
select * from tenk1 where (unique1 + random())::integer not in
(select ten from tenk2);
- QUERY PLAN
--------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------
Seq Scan on tenk1
- Filter: (NOT (ANY ((((unique1)::double precision + random()))::integer = (hashed SubPlan 1).col1)))
- SubPlan 1
+ Filter: (NOT (ANY ((((unique1)::double precision + random()))::integer = (hashed any_1).col1)))
+ SubPlan any_1
-> Seq Scan on tenk2
(4 rows)
QUERY PLAN
------------------------------------------------------
Aggregate
- InitPlan 1
+ InitPlan expr_1
-> Finalize Aggregate
-> Gather
Workers Planned: 2
-> Gather
Workers Planned: 4
-> Parallel Seq Scan on tenk1
- Filter: (unique1 = (InitPlan 1).col1)
+ Filter: (unique1 = (expr_1).col1)
(11 rows)
select count(*) from tenk1
explain (costs off)
select count((unique1)) from tenk1
where hundred = any ((select array_agg(i) from generate_series(1, 100, 15) i)::int[]);
- QUERY PLAN
----------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------------
Finalize Aggregate
- InitPlan 1
+ InitPlan expr_1
-> Aggregate
-> Function Scan on generate_series i
-> Gather
Workers Planned: 4
-> Partial Aggregate
-> Parallel Index Scan using tenk1_hundred on tenk1
- Index Cond: (hundred = ANY ((InitPlan 1).col1))
+ Index Cond: (hundred = ANY ((expr_1).col1))
(9 rows)
select count((unique1)) from tenk1
-> Append
-> Gather
Workers Planned: 4
- InitPlan 1
+ InitPlan expr_1
-> Limit
-> Gather
Workers Planned: 4
-> Parallel Seq Scan on tenk1 tenk1_2
Filter: (fivethous = 1)
-> Parallel Seq Scan on tenk1
- Filter: (fivethous = (InitPlan 1).col1)
+ Filter: (fivethous = (expr_1).col1)
-> Gather
Workers Planned: 4
- InitPlan 2
+ InitPlan expr_2
-> Limit
-> Gather
Workers Planned: 4
-> Parallel Seq Scan on tenk1 tenk1_3
Filter: (fivethous = 1)
-> Parallel Seq Scan on tenk1 tenk1_1
- Filter: (fivethous = (InitPlan 2).col1)
+ Filter: (fivethous = (expr_2).col1)
(23 rows)
-- test interaction with SRFs
EXPLAIN (VERBOSE, COSTS OFF)
SELECT generate_series(1, two), array(select generate_series(1, two))
FROM tenk1 ORDER BY tenthous;
- QUERY PLAN
----------------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------------
ProjectSet
- Output: generate_series(1, tenk1.two), ARRAY(SubPlan 1), tenk1.tenthous
+ Output: generate_series(1, tenk1.two), ARRAY(array_1), tenk1.tenthous
-> Gather Merge
Output: tenk1.two, tenk1.tenthous
Workers Planned: 4
Sort Key: tenk1.tenthous
-> Parallel Seq Scan on public.tenk1
Output: tenk1.tenthous, tenk1.two
- SubPlan 1
+ SubPlan array_1
-> ProjectSet
Output: generate_series(1, tenk1.two)
-> Result
QUERY PLAN
-------------------------------------------------------------------
Subquery Scan on tenk1_vw_sec
- Filter: ((SubPlan 1) < 100)
+ Filter: ((expr_1) < 100)
-> Gather
Workers Planned: 4
-> Parallel Index Only Scan using tenk1_unique1 on tenk1
- SubPlan 1
+ SubPlan expr_1
-> Aggregate
-> Seq Scan on int4_tbl
Filter: (f1 < tenk1_vw_sec.unique1)
QUERY PLAN
---------------------------------------------------------------------
Result
- Output: (InitPlan 1).col1
- InitPlan 1
+ Output: (expr_1).col1
+ InitPlan expr_1
-> Aggregate
Output: JSON_ARRAYAGG("*VALUES*".column1 RETURNING jsonb)
-> Values Scan on "*VALUES*"
-- Check ROWCOMPARE cases, both correlated and not
EXPLAIN (VERBOSE, COSTS OFF)
SELECT ROW(1, 2) = (SELECT f1, f2) AS eq FROM SUBSELECT_TBL;
- QUERY PLAN
------------------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------------------
Seq Scan on public.subselect_tbl
- Output: (((1 = (SubPlan 1).col1) AND (2 = (SubPlan 1).col2)))
- SubPlan 1
+ Output: (((1 = (rowcompare_1).col1) AND (2 = (rowcompare_1).col2)))
+ SubPlan rowcompare_1
-> Result
Output: subselect_tbl.f1, subselect_tbl.f2
(5 rows)
EXPLAIN (VERBOSE, COSTS OFF)
SELECT ROW(1, 2) = (SELECT 3, 4) AS eq FROM SUBSELECT_TBL;
- QUERY PLAN
------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Seq Scan on public.subselect_tbl
- Output: ((1 = (InitPlan 1).col1) AND (2 = (InitPlan 1).col2))
- InitPlan 1
+ Output: ((1 = (rowcompare_1).col1) AND (2 = (rowcompare_1).col2))
+ InitPlan rowcompare_1
-> Result
Output: 3, 4
(5 rows)
-- check materialization of an initplan reference (bug #14524)
explain (verbose, costs off)
select 1 = all (select (select 1));
- QUERY PLAN
--------------------------------------------
+ QUERY PLAN
+---------------------------------------
Result
- Output: (ALL (1 = (SubPlan 2).col1))
- SubPlan 2
+ Output: (ALL (1 = (all_1).col1))
+ SubPlan all_1
-> Materialize
- Output: ((InitPlan 1).col1)
- InitPlan 1
+ Output: ((expr_1).col1)
+ InitPlan expr_1
-> Result
Output: 1
-> Result
- Output: (InitPlan 1).col1
+ Output: (expr_1).col1
(10 rows)
select 1 = all (select (select 1));
QUERY PLAN
--------------------------------------
Seq Scan on int4_tbl o
- Filter: EXISTS(SubPlan 1)
- SubPlan 1
+ Filter: EXISTS(exists_1)
+ SubPlan exists_1
-> Limit
-> Seq Scan on int4_tbl i
Filter: (f1 = o.f1)
--
explain (verbose, costs off)
select 'foo'::text in (select 'bar'::name union all select 'bar'::name);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+-----------------------------------------------------
Result
- Output: (ANY ('foo'::text = (hashed SubPlan 1).col1))
- SubPlan 1
+ Output: (ANY ('foo'::text = (hashed any_1).col1))
+ SubPlan any_1
-> Append
-> Result
Output: 'bar'::name
--
explain (verbose, costs off)
select row(row(row(1))) = any (select row(row(1)));
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------
Result
- Output: (ANY ('("(1)")'::record = (SubPlan 1).col1))
- SubPlan 1
+ Output: (ANY ('("(1)")'::record = (any_1).col1))
+ SubPlan any_1
-> Materialize
Output: '("(1)")'::record
-> Result
create operator = (procedure=bogus_int8_text_eq, leftarg=int8, rightarg=text);
explain (costs off)
select * from int8_tbl where q1 in (select c1 from inner_text);
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------
Seq Scan on int8_tbl
- Filter: (ANY ((q1)::text = (hashed SubPlan 1).col1))
- SubPlan 1
+ Filter: (ANY ((q1)::text = (hashed any_1).col1))
+ SubPlan any_1
-> Seq Scan on inner_text
(4 rows)
language sql as 'select $1::text = $2 and $1::text = $2';
explain (costs off)
select * from int8_tbl where q1 in (select c1 from inner_text);
- QUERY PLAN
------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------------------------
Seq Scan on int8_tbl
- Filter: (ANY (((q1)::text = (hashed SubPlan 1).col1) AND ((q1)::text = (hashed SubPlan 1).col1)))
- SubPlan 1
+ Filter: (ANY (((q1)::text = (hashed any_1).col1) AND ((q1)::text = (hashed any_1).col1)))
+ SubPlan any_1
-> Seq Scan on inner_text
(4 rows)
language sql as 'select $2 = $1::text';
explain (costs off)
select * from int8_tbl where q1 in (select c1 from inner_text);
- QUERY PLAN
--------------------------------------------------
+ QUERY PLAN
+---------------------------------------------
Seq Scan on int8_tbl
- Filter: (ANY ((SubPlan 1).col1 = (q1)::text))
- SubPlan 1
+ Filter: (ANY ((any_1).col1 = (q1)::text))
+ SubPlan any_1
-> Materialize
-> Seq Scan on inner_text
(5 rows)
explain (costs off)
select count(*) from tenk1 t
where (exists(select 1 from tenk1 k where k.unique1 = t.unique2) or ten < 0);
- QUERY PLAN
---------------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------------
Aggregate
-> Seq Scan on tenk1 t
- Filter: ((ANY (unique2 = (hashed SubPlan 2).col1)) OR (ten < 0))
- SubPlan 2
+ Filter: ((ANY (unique2 = (hashed exists_2).col1)) OR (ten < 0))
+ SubPlan exists_2
-> Index Only Scan using tenk1_unique1 on tenk1 k
(5 rows)
Aggregate
-> Bitmap Heap Scan on tenk1 t
Recheck Cond: (thousand = 1)
- Filter: (EXISTS(SubPlan 1) OR (ten < 0))
+ Filter: (EXISTS(exists_1) OR (ten < 0))
-> Bitmap Index Scan on tenk1_thous_tenthous
Index Cond: (thousand = 1)
- SubPlan 1
+ SubPlan exists_1
-> Index Only Scan using tenk1_unique1 on tenk1 k
Index Cond: (unique1 = t.unique2)
(9 rows)
explain (costs off)
select * from exists_tbl t1
where (exists(select 1 from exists_tbl t2 where t1.c1 = t2.c2) or c3 < 0);
- QUERY PLAN
---------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------
Append
-> Seq Scan on exists_tbl_null t1_1
- Filter: (EXISTS(SubPlan 1) OR (c3 < 0))
- SubPlan 1
+ Filter: (EXISTS(exists_1) OR (c3 < 0))
+ SubPlan exists_1
-> Append
-> Seq Scan on exists_tbl_null t2_1
Filter: (t1_1.c1 = c2)
-> Seq Scan on exists_tbl_def t2_2
Filter: (t1_1.c1 = c2)
-> Seq Scan on exists_tbl_def t1_2
- Filter: ((ANY (c1 = (hashed SubPlan 2).col1)) OR (c3 < 0))
- SubPlan 2
+ Filter: ((ANY (c1 = (hashed exists_2).col1)) OR (c3 < 0))
+ SubPlan exists_2
-> Append
-> Seq Scan on exists_tbl_null t2_4
-> Seq Scan on exists_tbl_def t2_5
explain (verbose, costs off)
select x, x from
(select (select now()) as x from (values(1),(2)) v(y)) ss;
- QUERY PLAN
-------------------------------------------------
+ QUERY PLAN
+----------------------------------------
Values Scan on "*VALUES*"
- Output: (InitPlan 1).col1, (InitPlan 2).col1
- InitPlan 1
+ Output: (expr_1).col1, (expr_2).col1
+ InitPlan expr_1
-> Result
Output: now()
- InitPlan 2
+ InitPlan expr_2
-> Result
Output: now()
(8 rows)
explain (verbose, costs off)
select x, x from
(select (select random()) as x from (values(1),(2)) v(y)) ss;
- QUERY PLAN
------------------------------------
+ QUERY PLAN
+----------------------------------
Subquery Scan on ss
Output: ss.x, ss.x
-> Values Scan on "*VALUES*"
- Output: (InitPlan 1).col1
- InitPlan 1
+ Output: (expr_1).col1
+ InitPlan expr_1
-> Result
Output: random()
(7 rows)
QUERY PLAN
----------------------------------------------------------------------
Values Scan on "*VALUES*"
- Output: (SubPlan 1), (SubPlan 2)
- SubPlan 1
+ Output: (expr_1), (expr_2)
+ SubPlan expr_1
-> Result
Output: now()
One-Time Filter: ("*VALUES*".column1 = "*VALUES*".column1)
- SubPlan 2
+ SubPlan expr_2
-> Result
Output: now()
One-Time Filter: ("*VALUES*".column1 = "*VALUES*".column1)
Subquery Scan on ss
Output: ss.x, ss.x
-> Values Scan on "*VALUES*"
- Output: (SubPlan 1)
- SubPlan 1
+ Output: (expr_1)
+ SubPlan expr_1
-> Result
Output: random()
One-Time Filter: ("*VALUES*".column1 = "*VALUES*".column1)
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Aggregate
- Output: sum((((ANY (i.ten = (hashed SubPlan 1).col1))))::integer)
+ Output: sum((((ANY (i.ten = (hashed any_1).col1))))::integer)
-> Nested Loop
- Output: ((ANY (i.ten = (hashed SubPlan 1).col1)))
+ Output: ((ANY (i.ten = (hashed any_1).col1)))
-> Seq Scan on public.onek o
Output: o.unique1, o.unique2, o.two, o.four, o.ten, o.twenty, o.hundred, o.thousand, o.twothousand, o.fivethous, o.tenthous, o.odd, o.even, o.stringu1, o.stringu2, o.string4
Filter: (o.ten = 0)
-> Index Scan using onek_unique1 on public.onek i
- Output: (ANY (i.ten = (hashed SubPlan 1).col1)), random()
+ Output: (ANY (i.ten = (hashed any_1).col1)), random()
Index Cond: (i.unique1 = o.unique1)
- SubPlan 1
+ SubPlan any_1
-> Seq Scan on public.int4_tbl
Output: int4_tbl.f1
Filter: (int4_tbl.f1 <= o.hundred)
----------------------------------------
Values Scan on "*VALUES*"
Output: "*VALUES*".column1
- SubPlan 1
+ SubPlan any_1
-> Values Scan on "*VALUES*_1"
Output: "*VALUES*_1".column1
(5 rows)
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Nested Loop Semi Join
Output: int4_tbl.f1
- Join Filter: (CASE WHEN (ANY (int4_tbl.f1 = (hashed SubPlan 1).col1)) THEN int4_tbl.f1 ELSE NULL::integer END = b.ten)
+ Join Filter: (CASE WHEN (ANY (int4_tbl.f1 = (hashed any_1).col1)) THEN int4_tbl.f1 ELSE NULL::integer END = b.ten)
-> Seq Scan on public.int4_tbl
Output: int4_tbl.f1
-> Seq Scan on public.tenk1 b
Output: b.unique1, b.unique2, b.two, b.four, b.ten, b.twenty, b.hundred, b.thousand, b.twothousand, b.fivethous, b.tenthous, b.odd, b.even, b.stringu1, b.stringu2, b.string4
- SubPlan 1
+ SubPlan any_1
-> Index Only Scan using tenk1_unique1 on public.tenk1 a
Output: a.unique1
(10 rows)
(select 1 from tenk2 B
where A.hundred in (select C.hundred FROM tenk2 C
WHERE c.odd = b.odd));
- QUERY PLAN
------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------
Nested Loop Semi Join
- Join Filter: (ANY (a.hundred = (SubPlan 1).col1))
+ Join Filter: (ANY (a.hundred = (any_1).col1))
-> Seq Scan on tenk1 a
-> Materialize
-> Seq Scan on tenk2 b
- SubPlan 1
+ SubPlan any_1
-> Seq Scan on tenk2 c
Filter: (odd = b.odd)
(8 rows)
explain (costs off)
SELECT * FROM tenk1 A LEFT JOIN tenk2 B
ON A.hundred in (SELECT c.hundred FROM tenk2 C WHERE c.odd = b.odd);
- QUERY PLAN
------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------
Nested Loop Left Join
- Join Filter: (ANY (a.hundred = (SubPlan 1).col1))
+ Join Filter: (ANY (a.hundred = (any_1).col1))
-> Seq Scan on tenk1 a
-> Materialize
-> Seq Scan on tenk2 b
- SubPlan 1
+ SubPlan any_1
-> Seq Scan on tenk2 c
Filter: (odd = b.odd)
(8 rows)
explain (costs off)
SELECT * FROM tenk1 A LEFT JOIN tenk2 B
ON B.hundred in (SELECT c.hundred FROM tenk2 C WHERE c.odd = a.odd);
- QUERY PLAN
------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------
Nested Loop Left Join
- Join Filter: (ANY (b.hundred = (SubPlan 1).col1))
+ Join Filter: (ANY (b.hundred = (any_1).col1))
-> Seq Scan on tenk1 a
-> Materialize
-> Seq Scan on tenk2 b
- SubPlan 1
+ SubPlan any_1
-> Seq Scan on tenk2 c
Filter: (odd = a.odd)
(8 rows)
Filter: (b.hundred = "ANY_subquery".min)
-> Result
Replaces: Aggregate
- InitPlan 1
+ InitPlan minmax_1
-> Limit
-> Index Scan using tenk2_hundred on tenk2 c
Index Cond: (hundred IS NOT NULL)
-> Seq Scan on onek t
-> Values Scan on "*VALUES*"
Filter: (t.unique1 = column1)
- SubPlan 1
+ SubPlan any_1
-> Index Only Scan using onek_unique2 on onek c
Index Cond: (unique2 = t.unique1)
(7 rows)
-> Sort
Sort Key: "*VALUES*".column1
-> Values Scan on "*VALUES*"
- SubPlan 1
+ SubPlan any_1
-> Index Only Scan using onek_unique2 on onek c
Filter: ((unique2)::double precision = ANY ('{0.479425538604203,2}'::double precision[]))
-> Index Scan using onek_unique1 on onek t
-> Sort
Sort Key: "*VALUES*".column1
-> Values Scan on "*VALUES*"
- SubPlan 1
+ SubPlan any_1
-> Result
-> Index Scan using onek_unique1 on onek t
Index Cond: (unique1 = "*VALUES*".column1)
---------------------------------------------------------
Insert on base_tbl b
-> Result
- SubPlan 1
+ SubPlan exists_1
-> Index Only Scan using ref_tbl_pkey on ref_tbl r
Index Cond: (a = b.a)
(5 rows)
-> Seq Scan on base_tbl b
-> Hash
-> Seq Scan on ref_tbl r
- SubPlan 1
+ SubPlan exists_1
-> Index Only Scan using ref_tbl_pkey on ref_tbl r_1
Index Cond: (a = b.a)
(9 rows)
QUERY PLAN
-----------------------------------------------------------
Insert on base_tbl
- InitPlan 1
+ InitPlan exists_1
-> Index Only Scan using base_tbl_pkey on base_tbl t
Index Cond: (id = 2)
-> Result
- One-Time Filter: ((InitPlan 1).col1 IS NOT TRUE)
+ One-Time Filter: ((exists_1).col1 IS NOT TRUE)
Update on base_tbl
- InitPlan 1
+ InitPlan exists_1
-> Index Only Scan using base_tbl_pkey on base_tbl t
Index Cond: (id = 2)
-> Result
- One-Time Filter: (InitPlan 1).col1
+ One-Time Filter: (exists_1).col1
-> Index Scan using base_tbl_pkey on base_tbl
Index Cond: (id = 2)
(15 rows)
EXPLAIN (VERBOSE, COSTS OFF)
UPDATE v1 SET a=100 WHERE snoop(a) AND leakproof(a) AND a < 7 AND a != 6;
- QUERY PLAN
------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------
Update on public.t1
Update on public.t1 t1_1
Update on public.t11 t1_2
-> Index Scan using t1_a_idx on public.t1 t1_1
Output: t1_1.tableoid, t1_1.ctid
Index Cond: ((t1_1.a > 5) AND (t1_1.a < 7))
- Filter: ((t1_1.a <> 6) AND EXISTS(SubPlan 1) AND snoop(t1_1.a) AND leakproof(t1_1.a))
- SubPlan 1
+ Filter: ((t1_1.a <> 6) AND EXISTS(exists_1) AND snoop(t1_1.a) AND leakproof(t1_1.a))
+ SubPlan exists_1
-> Append
-> Seq Scan on public.t12 t12_1
Filter: (t12_1.a = t1_1.a)
-> Index Scan using t11_a_idx on public.t11 t1_2
Output: t1_2.tableoid, t1_2.ctid
Index Cond: ((t1_2.a > 5) AND (t1_2.a < 7))
- Filter: ((t1_2.a <> 6) AND EXISTS(SubPlan 1) AND snoop(t1_2.a) AND leakproof(t1_2.a))
+ Filter: ((t1_2.a <> 6) AND EXISTS(exists_1) AND snoop(t1_2.a) AND leakproof(t1_2.a))
-> Index Scan using t12_a_idx on public.t12 t1_3
Output: t1_3.tableoid, t1_3.ctid
Index Cond: ((t1_3.a > 5) AND (t1_3.a < 7))
- Filter: ((t1_3.a <> 6) AND EXISTS(SubPlan 1) AND snoop(t1_3.a) AND leakproof(t1_3.a))
+ Filter: ((t1_3.a <> 6) AND EXISTS(exists_1) AND snoop(t1_3.a) AND leakproof(t1_3.a))
-> Index Scan using t111_a_idx on public.t111 t1_4
Output: t1_4.tableoid, t1_4.ctid
Index Cond: ((t1_4.a > 5) AND (t1_4.a < 7))
- Filter: ((t1_4.a <> 6) AND EXISTS(SubPlan 1) AND snoop(t1_4.a) AND leakproof(t1_4.a))
+ Filter: ((t1_4.a <> 6) AND EXISTS(exists_1) AND snoop(t1_4.a) AND leakproof(t1_4.a))
(30 rows)
UPDATE v1 SET a=100 WHERE snoop(a) AND leakproof(a) AND a < 7 AND a != 6;
EXPLAIN (VERBOSE, COSTS OFF)
UPDATE v1 SET a=a+1 WHERE snoop(a) AND leakproof(a) AND a = 8;
- QUERY PLAN
------------------------------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------
Update on public.t1
Update on public.t1 t1_1
Update on public.t11 t1_2
-> Index Scan using t1_a_idx on public.t1 t1_1
Output: t1_1.a, t1_1.tableoid, t1_1.ctid
Index Cond: ((t1_1.a > 5) AND (t1_1.a = 8))
- Filter: (EXISTS(SubPlan 1) AND snoop(t1_1.a) AND leakproof(t1_1.a))
- SubPlan 1
+ Filter: (EXISTS(exists_1) AND snoop(t1_1.a) AND leakproof(t1_1.a))
+ SubPlan exists_1
-> Append
-> Seq Scan on public.t12 t12_1
Filter: (t12_1.a = t1_1.a)
-> Index Scan using t11_a_idx on public.t11 t1_2
Output: t1_2.a, t1_2.tableoid, t1_2.ctid
Index Cond: ((t1_2.a > 5) AND (t1_2.a = 8))
- Filter: (EXISTS(SubPlan 1) AND snoop(t1_2.a) AND leakproof(t1_2.a))
+ Filter: (EXISTS(exists_1) AND snoop(t1_2.a) AND leakproof(t1_2.a))
-> Index Scan using t12_a_idx on public.t12 t1_3
Output: t1_3.a, t1_3.tableoid, t1_3.ctid
Index Cond: ((t1_3.a > 5) AND (t1_3.a = 8))
- Filter: (EXISTS(SubPlan 1) AND snoop(t1_3.a) AND leakproof(t1_3.a))
+ Filter: (EXISTS(exists_1) AND snoop(t1_3.a) AND leakproof(t1_3.a))
-> Index Scan using t111_a_idx on public.t111 t1_4
Output: t1_4.a, t1_4.tableoid, t1_4.ctid
Index Cond: ((t1_4.a > 5) AND (t1_4.a = 8))
- Filter: (EXISTS(SubPlan 1) AND snoop(t1_4.a) AND leakproof(t1_4.a))
+ Filter: (EXISTS(exists_1) AND snoop(t1_4.a) AND leakproof(t1_4.a))
(30 rows)
UPDATE v1 SET a=a+1 WHERE snoop(a) AND leakproof(a) AND a = 8;
CREATE VIEW v2 WITH (security_barrier = true) AS
SELECT * FROM v1 WHERE EXISTS (SELECT 1);
EXPLAIN (COSTS OFF) UPDATE v2 SET a = 1;
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------
Update on t1
- InitPlan 1
+ InitPlan exists_1
-> Result
-> Merge Join
Merge Cond: (t1.a = v1.a)
Sort Key: v1.a
-> Subquery Scan on v1
-> Result
- One-Time Filter: (InitPlan 1).col1
+ One-Time Filter: (exists_1).col1
-> Seq Scan on t1 t1_1
(14 rows)
UPDATE update_test t
SET (a, b) = (SELECT b, a FROM update_test s WHERE s.a = t.a)
WHERE CURRENT_USER = SESSION_USER;
- QUERY PLAN
---------------------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------------------------------
Update on public.update_test t
-> Result
- Output: (SubPlan 1).col1, (SubPlan 1).col2, (rescan SubPlan 1), t.ctid
+ Output: (multiexpr_1).col1, (multiexpr_1).col2, (rescan multiexpr_1), t.ctid
One-Time Filter: (CURRENT_USER = SESSION_USER)
-> Seq Scan on public.update_test t
Output: t.a, t.ctid
- SubPlan 1
+ SubPlan multiexpr_1
-> Seq Scan on public.update_test s
Output: s.b, s.a
Filter: (s.a = t.a)
(SELECT ntile(s1.x) OVER () AS c
FROM (SELECT (SELECT 1) AS x) AS s1) s
WHERE s.c = 1;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------
Subquery Scan on s
Filter: (s.c = 1)
-> WindowAgg
Window: w1 AS (ROWS UNBOUNDED PRECEDING)
- Run Condition: (ntile((InitPlan 1).col1) OVER w1 <= 1)
- InitPlan 1
+ Run Condition: (ntile((expr_1).col1) OVER w1 <= 1)
+ InitPlan expr_1
-> Result
-> Result
(8 rows)
Filter: (emp.c = 1)
-> WindowAgg
Window: w1 AS (ORDER BY empsalary.empno)
- InitPlan 1
+ InitPlan expr_1
-> Result
-> Sort
Sort Key: empsalary.empno DESC
Output: o.k, o.v, o.*
-> Result
Output: 0, 'merge source SubPlan'::text
- SubPlan 2
+ SubPlan expr_1
-> Limit
Output: ((cte_basic.b || ' merge update'::text))
-> CTE Scan on cte_basic
CTE cte_init
-> Result
Output: 1, 'cte_init val'::text
- InitPlan 2
+ InitPlan expr_1
-> Limit
Output: ((cte_init.b || ' merge update'::text))
-> CTE Scan on cte_init
CTE merge_source_cte
-> Result
Output: 15, 'merge_source_cte val'::text
- InitPlan 2
+ InitPlan expr_1
-> CTE Scan on merge_source_cte merge_source_cte_1
Output: ((merge_source_cte_1.b || (merge_source_cte_1.*)::text) || ' merge update'::text)
Filter: (merge_source_cte_1.a = 15)
- InitPlan 3
+ InitPlan expr_2
-> CTE Scan on merge_source_cte merge_source_cte_2
Output: ((merge_source_cte_2.*)::text || ' merge insert'::text)
-> Hash Right Join
projects / users / rhaas / postgres.git / commitdiff