clean-up-tree-walker-warnings-1.patch
text/x-diff
Filename: clean-up-tree-walker-warnings-1.patch
Type: text/x-diff
Part: 0
Patch
Format: unified
| File | + | − |
|---|---|---|
| src/backend/catalog/dependency.c | 6 | 7 |
| src/backend/commands/explain.c | 4 | 3 |
| src/backend/commands/lockcmds.c | 5 | 5 |
| src/backend/commands/publicationcmds.c | 7 | 6 |
| src/backend/executor/execExpr.c | 5 | 4 |
| src/backend/executor/execIndexing.c | 6 | 5 |
| src/backend/executor/execMain.c | 1 | 1 |
| src/backend/executor/execParallel.c | 27 | 26 |
| src/backend/executor/execProcnode.c | 2 | 2 |
| src/backend/executor/nodeAgg.c | 6 | 5 |
| src/backend/nodes/nodeFuncs.c | 279 | 282 |
| src/backend/optimizer/path/costsize.c | 5 | 4 |
| src/backend/optimizer/plan/createplan.c | 6 | 7 |
| src/backend/optimizer/plan/setrefs.c | 40 | 40 |
| src/backend/optimizer/plan/subselect.c | 34 | 31 |
| src/backend/optimizer/prep/prepagg.c | 5 | 4 |
| src/backend/optimizer/prep/prepjointree.c | 10 | 10 |
| src/backend/optimizer/util/appendinfo.c | 7 | 9 |
| src/backend/optimizer/util/clauses.c | 40 | 36 |
| src/backend/optimizer/util/tlist.c | 5 | 5 |
| src/backend/optimizer/util/var.c | 39 | 40 |
| src/backend/parser/parse_agg.c | 18 | 22 |
| src/backend/parser/parse_collate.c | 7 | 5 |
| src/backend/parser/parse_cte.c | 9 | 10 |
| src/backend/parser/parse_param.c | 6 | 5 |
| src/backend/partitioning/partprune.c | 5 | 4 |
| src/backend/rewrite/rewriteDefine.c | 5 | 4 |
| src/backend/rewrite/rewriteHandler.c | 9 | 7 |
| src/backend/rewrite/rewriteManip.c | 47 | 47 |
| src/backend/utils/cache/plancache.c | 5 | 4 |
| src/include/executor/executor.h | 1 | 1 |
| src/include/nodes/nodeFuncs.h | 26 | 12 |
| src/include/optimizer/planmain.h | 1 | 1 |
| src/include/rewrite/rewriteManip.h | 1 | 2 |
diff --git a/src/backend/catalog/dependency.c b/src/backend/catalog/dependency.c
index 39768fa22b..f127f20fd8 100644
--- a/src/backend/catalog/dependency.c
+++ b/src/backend/catalog/dependency.c
@@ -206,8 +206,7 @@ static void reportDependentObjects(const ObjectAddresses *targetObjects,
static void deleteOneObject(const ObjectAddress *object,
Relation *depRel, int32 flags);
static void doDeletion(const ObjectAddress *object, int flags);
-static bool find_expr_references_walker(Node *node,
- find_expr_references_context *context);
+static bool find_expr_references_walker(Node *node, void *ctx);
static void process_function_rte_ref(RangeTblEntry *rte, AttrNumber attnum,
find_expr_references_context *context);
static void eliminate_duplicate_dependencies(ObjectAddresses *addrs);
@@ -1738,9 +1737,10 @@ recordDependencyOnSingleRelExpr(const ObjectAddress *depender,
* the collation is being freshly introduced to the expression.
*/
static bool
-find_expr_references_walker(Node *node,
- find_expr_references_context *context)
+find_expr_references_walker(Node *node, void *ctx)
{
+ find_expr_references_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Var))
@@ -2283,7 +2283,7 @@ find_expr_references_walker(Node *node,
context->rtables = lcons(query->rtable, context->rtables);
result = query_tree_walker(query,
find_expr_references_walker,
- (void *) context,
+ ctx,
QTW_IGNORE_JOINALIASES |
QTW_EXAMINE_SORTGROUP);
context->rtables = list_delete_first(context->rtables);
@@ -2352,8 +2352,7 @@ find_expr_references_walker(Node *node,
/* fall through to examine arguments */
}
- return expression_tree_walker(node, find_expr_references_walker,
- (void *) context);
+ return expression_tree_walker(node, find_expr_references_walker, ctx);
}
/*
diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 053d2ca5ae..671a41d3b6 100644
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -63,7 +63,7 @@ static void ExplainPrintJIT(ExplainState *es, int jit_flags,
static void report_triggers(ResultRelInfo *rInfo, bool show_relname,
ExplainState *es);
static double elapsed_time(instr_time *starttime);
-static bool ExplainPreScanNode(PlanState *planstate, Bitmapset **rels_used);
+static bool ExplainPreScanNode(PlanState *planstate, void *ctx);
static void ExplainNode(PlanState *planstate, List *ancestors,
const char *relationship, const char *plan_name,
ExplainState *es);
@@ -1089,8 +1089,9 @@ elapsed_time(instr_time *starttime)
* that never appear in the EXPLAIN output (such as inheritance parents).
*/
static bool
-ExplainPreScanNode(PlanState *planstate, Bitmapset **rels_used)
+ExplainPreScanNode(PlanState *planstate, void *ctx)
{
+ Bitmapset **rels_used = ctx;
Plan *plan = planstate->plan;
switch (nodeTag(plan))
@@ -1139,7 +1140,7 @@ ExplainPreScanNode(PlanState *planstate, Bitmapset **rels_used)
break;
}
- return planstate_tree_walker(planstate, ExplainPreScanNode, rels_used);
+ return planstate_tree_walker(planstate, ExplainPreScanNode, ctx);
}
/*
diff --git a/src/backend/commands/lockcmds.c b/src/backend/commands/lockcmds.c
index b97b8b0435..adaad13310 100644
--- a/src/backend/commands/lockcmds.c
+++ b/src/backend/commands/lockcmds.c
@@ -175,8 +175,10 @@ typedef struct
} LockViewRecurse_context;
static bool
-LockViewRecurse_walker(Node *node, LockViewRecurse_context *context)
+LockViewRecurse_walker(Node *node, void *ctx)
{
+ LockViewRecurse_context *context = ctx;
+
if (node == NULL)
return false;
@@ -242,13 +244,11 @@ LockViewRecurse_walker(Node *node, LockViewRecurse_context *context)
return query_tree_walker(query,
LockViewRecurse_walker,
- context,
+ ctx,
QTW_IGNORE_JOINALIASES);
}
- return expression_tree_walker(node,
- LockViewRecurse_walker,
- context);
+ return expression_tree_walker(node, LockViewRecurse_walker, ctx);
}
static void
diff --git a/src/backend/commands/publicationcmds.c b/src/backend/commands/publicationcmds.c
index 8b574b86c4..b84e841291 100644
--- a/src/backend/commands/publicationcmds.c
+++ b/src/backend/commands/publicationcmds.c
@@ -257,8 +257,10 @@ CheckObjSchemaNotAlreadyInPublication(List *rels, List *schemaidlist,
* not part of REPLICA IDENTITY, false otherwise.
*/
static bool
-contain_invalid_rfcolumn_walker(Node *node, rf_context *context)
+contain_invalid_rfcolumn_walker(Node *node, void *ctx)
{
+ rf_context *context = ctx;
+
if (node == NULL)
return false;
@@ -285,8 +287,7 @@ contain_invalid_rfcolumn_walker(Node *node, rf_context *context)
return true;
}
- return expression_tree_walker(node, contain_invalid_rfcolumn_walker,
- (void *) context);
+ return expression_tree_walker(node, contain_invalid_rfcolumn_walker, ctx);
}
/*
@@ -549,8 +550,9 @@ expr_allowed_in_node(Node *node, ParseState *pstate, char **errdetail_msg)
* We can allow other node types after more analysis and testing.
*/
static bool
-check_simple_rowfilter_expr_walker(Node *node, ParseState *pstate)
+check_simple_rowfilter_expr_walker(Node *node, void *ctx)
{
+ ParseState *pstate = ctx;
char *errdetail_msg = NULL;
if (node == NULL)
@@ -632,8 +634,7 @@ check_simple_rowfilter_expr_walker(Node *node, ParseState *pstate)
errdetail("%s", errdetail_msg),
parser_errposition(pstate, exprLocation(node))));
- return expression_tree_walker(node, check_simple_rowfilter_expr_walker,
- (void *) pstate);
+ return expression_tree_walker(node, check_simple_rowfilter_expr_walker, ctx);
}
/*
diff --git a/src/backend/executor/execExpr.c b/src/backend/executor/execExpr.c
index 25a94bbaaa..b4a6f360c1 100644
--- a/src/backend/executor/execExpr.c
+++ b/src/backend/executor/execExpr.c
@@ -66,7 +66,7 @@ static void ExecInitFunc(ExprEvalStep *scratch, Expr *node, List *args,
ExprState *state);
static void ExecInitExprSlots(ExprState *state, Node *node);
static void ExecPushExprSlots(ExprState *state, LastAttnumInfo *info);
-static bool get_last_attnums_walker(Node *node, LastAttnumInfo *info);
+static bool get_last_attnums_walker(Node *node, void *ctx);
static bool ExecComputeSlotInfo(ExprState *state, ExprEvalStep *op);
static void ExecInitWholeRowVar(ExprEvalStep *scratch, Var *variable,
ExprState *state);
@@ -2618,8 +2618,10 @@ ExecPushExprSlots(ExprState *state, LastAttnumInfo *info)
* get_last_attnums_walker: expression walker for ExecInitExprSlots
*/
static bool
-get_last_attnums_walker(Node *node, LastAttnumInfo *info)
+get_last_attnums_walker(Node *node, void *ctx)
{
+ LastAttnumInfo *info = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Var))
@@ -2658,8 +2660,7 @@ get_last_attnums_walker(Node *node, LastAttnumInfo *info)
return false;
if (IsA(node, GroupingFunc))
return false;
- return expression_tree_walker(node, get_last_attnums_walker,
- (void *) info);
+ return expression_tree_walker(node, get_last_attnums_walker, ctx);
}
/*
diff --git a/src/backend/executor/execIndexing.c b/src/backend/executor/execIndexing.c
index 6a8735edf7..b6ea05f13a 100644
--- a/src/backend/executor/execIndexing.c
+++ b/src/backend/executor/execIndexing.c
@@ -139,8 +139,8 @@ static bool index_recheck_constraint(Relation index, Oid *constr_procs,
static bool index_unchanged_by_update(ResultRelInfo *resultRelInfo,
EState *estate, IndexInfo *indexInfo,
Relation indexRelation);
-static bool index_expression_changed_walker(Node *node,
- Bitmapset *allUpdatedCols);
+static bool index_expression_changed_walker(Node *node, void *ctx);
+
/* ----------------------------------------------------------------
* ExecOpenIndices
@@ -1052,8 +1052,10 @@ index_unchanged_by_update(ResultRelInfo *resultRelInfo, EState *estate,
* Returns true when Var that appears within allUpdatedCols located.
*/
static bool
-index_expression_changed_walker(Node *node, Bitmapset *allUpdatedCols)
+index_expression_changed_walker(Node *node, void *ctx)
{
+ Bitmapset *allUpdatedCols = ctx;
+
if (node == NULL)
return false;
@@ -1072,6 +1074,5 @@ index_expression_changed_walker(Node *node, Bitmapset *allUpdatedCols)
return false;
}
- return expression_tree_walker(node, index_expression_changed_walker,
- (void *) allUpdatedCols);
+ return expression_tree_walker(node, index_expression_changed_walker, ctx);
}
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index ef2fd46092..e0b73da435 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -1691,7 +1691,7 @@ ExecutePlan(EState *estate,
* point.
*/
if (!(estate->es_top_eflags & EXEC_FLAG_BACKWARD))
- (void) ExecShutdownNode(planstate);
+ (void) ExecShutdownNode(planstate, NULL);
if (use_parallel_mode)
ExitParallelMode();
diff --git a/src/backend/executor/execParallel.c b/src/backend/executor/execParallel.c
index f1fd7f7e8b..d7f402091f 100644
--- a/src/backend/executor/execParallel.c
+++ b/src/backend/executor/execParallel.c
@@ -126,16 +126,12 @@ typedef struct ExecParallelInitializeDSMContext
/* Helper functions that run in the parallel leader. */
static char *ExecSerializePlan(Plan *plan, EState *estate);
-static bool ExecParallelEstimate(PlanState *node,
- ExecParallelEstimateContext *e);
-static bool ExecParallelInitializeDSM(PlanState *node,
- ExecParallelInitializeDSMContext *d);
+static bool ExecParallelEstimate(PlanState *node, void *ctx);
+static bool ExecParallelInitializeDSM(PlanState *node, void *ctx);
static shm_mq_handle **ExecParallelSetupTupleQueues(ParallelContext *pcxt,
bool reinitialize);
-static bool ExecParallelReInitializeDSM(PlanState *planstate,
- ParallelContext *pcxt);
-static bool ExecParallelRetrieveInstrumentation(PlanState *planstate,
- SharedExecutorInstrumentation *instrumentation);
+static bool ExecParallelReInitializeDSM(PlanState *planstate, void *ctx);
+static bool ExecParallelRetrieveInstrumentation(PlanState *planstate, void *ctx);
/* Helper function that runs in the parallel worker. */
static DestReceiver *ExecParallelGetReceiver(dsm_segment *seg, shm_toc *toc);
@@ -227,8 +223,10 @@ ExecSerializePlan(Plan *plan, EState *estate)
* we know how many Instrumentation structures we need.
*/
static bool
-ExecParallelEstimate(PlanState *planstate, ExecParallelEstimateContext *e)
+ExecParallelEstimate(PlanState *planstate, void *ctx)
{
+ ExecParallelEstimateContext *e = ctx;
+
if (planstate == NULL)
return false;
@@ -301,7 +299,7 @@ ExecParallelEstimate(PlanState *planstate, ExecParallelEstimateContext *e)
break;
}
- return planstate_tree_walker(planstate, ExecParallelEstimate, e);
+ return planstate_tree_walker(planstate, ExecParallelEstimate, ctx);
}
/*
@@ -436,9 +434,10 @@ RestoreParamExecParams(char *start_address, EState *estate)
* parallel execution.
*/
static bool
-ExecParallelInitializeDSM(PlanState *planstate,
- ExecParallelInitializeDSMContext *d)
+ExecParallelInitializeDSM(PlanState *planstate, void *ctx)
{
+ ExecParallelInitializeDSMContext *d = ctx;
+
if (planstate == NULL)
return false;
@@ -525,7 +524,7 @@ ExecParallelInitializeDSM(PlanState *planstate,
break;
}
- return planstate_tree_walker(planstate, ExecParallelInitializeDSM, d);
+ return planstate_tree_walker(planstate, ExecParallelInitializeDSM, ctx);
}
/*
@@ -944,9 +943,10 @@ ExecParallelReinitialize(PlanState *planstate,
* Traverse plan tree to reinitialize per-node dynamic shared memory state
*/
static bool
-ExecParallelReInitializeDSM(PlanState *planstate,
- ParallelContext *pcxt)
+ExecParallelReInitializeDSM(PlanState *planstate, void *ctx)
{
+ ParallelContext *pcxt = ctx;
+
if (planstate == NULL)
return false;
@@ -1005,7 +1005,7 @@ ExecParallelReInitializeDSM(PlanState *planstate,
break;
}
- return planstate_tree_walker(planstate, ExecParallelReInitializeDSM, pcxt);
+ return planstate_tree_walker(planstate, ExecParallelReInitializeDSM, ctx);
}
/*
@@ -1013,9 +1013,9 @@ ExecParallelReInitializeDSM(PlanState *planstate,
* dynamic shared memory.
*/
static bool
-ExecParallelRetrieveInstrumentation(PlanState *planstate,
- SharedExecutorInstrumentation *instrumentation)
+ExecParallelRetrieveInstrumentation(PlanState *planstate, void *ctx)
{
+ SharedExecutorInstrumentation *instrumentation = ctx;
Instrumentation *instrument;
int i;
int n;
@@ -1075,7 +1075,7 @@ ExecParallelRetrieveInstrumentation(PlanState *planstate,
}
return planstate_tree_walker(planstate, ExecParallelRetrieveInstrumentation,
- instrumentation);
+ ctx);
}
/*
@@ -1259,12 +1259,12 @@ ExecParallelGetQueryDesc(shm_toc *toc, DestReceiver *receiver,
* dynamic shared memory, so that the parallel leader can retrieve it.
*/
static bool
-ExecParallelReportInstrumentation(PlanState *planstate,
- SharedExecutorInstrumentation *instrumentation)
+ExecParallelReportInstrumentation(PlanState *planstate, void *ctx)
{
- int i;
+ SharedExecutorInstrumentation *instrumentation = ctx;
int plan_node_id = planstate->plan->plan_node_id;
Instrumentation *instrument;
+ int i;
InstrEndLoop(planstate->instrument);
@@ -1291,7 +1291,7 @@ ExecParallelReportInstrumentation(PlanState *planstate,
InstrAggNode(&instrument[ParallelWorkerNumber], planstate->instrument);
return planstate_tree_walker(planstate, ExecParallelReportInstrumentation,
- instrumentation);
+ ctx);
}
/*
@@ -1300,8 +1300,10 @@ ExecParallelReportInstrumentation(PlanState *planstate,
* is allocated and initialized by executor; that is, after ExecutorStart().
*/
static bool
-ExecParallelInitializeWorker(PlanState *planstate, ParallelWorkerContext *pwcxt)
+ExecParallelInitializeWorker(PlanState *planstate, void *ctx)
{
+ ParallelWorkerContext *pwcxt = ctx;
+
if (planstate == NULL)
return false;
@@ -1370,8 +1372,7 @@ ExecParallelInitializeWorker(PlanState *planstate, ParallelWorkerContext *pwcxt)
break;
}
- return planstate_tree_walker(planstate, ExecParallelInitializeWorker,
- pwcxt);
+ return planstate_tree_walker(planstate, ExecParallelInitializeWorker, ctx);
}
/*
diff --git a/src/backend/executor/execProcnode.c b/src/backend/executor/execProcnode.c
index b5667e53e5..18d9096be0 100644
--- a/src/backend/executor/execProcnode.c
+++ b/src/backend/executor/execProcnode.c
@@ -769,7 +769,7 @@ ExecEndNode(PlanState *node)
* and release any resources still held.
*/
bool
-ExecShutdownNode(PlanState *node)
+ExecShutdownNode(PlanState *node, void *ctx)
{
if (node == NULL)
return false;
@@ -789,7 +789,7 @@ ExecShutdownNode(PlanState *node)
if (node->instrument && node->instrument->running)
InstrStartNode(node->instrument);
- planstate_tree_walker(node, ExecShutdownNode, NULL);
+ planstate_tree_walker(node, ExecShutdownNode, ctx);
switch (nodeTag(node))
{
diff --git a/src/backend/executor/nodeAgg.c b/src/backend/executor/nodeAgg.c
index 933c304901..1e31fe74e9 100644
--- a/src/backend/executor/nodeAgg.c
+++ b/src/backend/executor/nodeAgg.c
@@ -401,7 +401,7 @@ static void finalize_aggregates(AggState *aggstate,
static TupleTableSlot *project_aggregates(AggState *aggstate);
static void find_cols(AggState *aggstate, Bitmapset **aggregated,
Bitmapset **unaggregated);
-static bool find_cols_walker(Node *node, FindColsContext *context);
+static bool find_cols_walker(Node *node, void *ctx);
static void build_hash_tables(AggState *aggstate);
static void build_hash_table(AggState *aggstate, int setno, long nbuckets);
static void hashagg_recompile_expressions(AggState *aggstate, bool minslot,
@@ -1414,8 +1414,10 @@ find_cols(AggState *aggstate, Bitmapset **aggregated, Bitmapset **unaggregated)
}
static bool
-find_cols_walker(Node *node, FindColsContext *context)
+find_cols_walker(Node *node, void *ctx)
{
+ FindColsContext *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Var))
@@ -1437,12 +1439,11 @@ find_cols_walker(Node *node, FindColsContext *context)
{
Assert(!context->is_aggref);
context->is_aggref = true;
- expression_tree_walker(node, find_cols_walker, (void *) context);
+ expression_tree_walker(node, find_cols_walker, ctx);
context->is_aggref = false;
return false;
}
- return expression_tree_walker(node, find_cols_walker,
- (void *) context);
+ return expression_tree_walker(node, find_cols_walker, ctx);
}
/*
diff --git a/src/backend/nodes/nodeFuncs.c b/src/backend/nodes/nodeFuncs.c
index 3bac350bf5..06363dab40 100644
--- a/src/backend/nodes/nodeFuncs.c
+++ b/src/backend/nodes/nodeFuncs.c
@@ -27,10 +27,12 @@
static bool expression_returns_set_walker(Node *node, void *context);
static int leftmostLoc(int loc1, int loc2);
static bool fix_opfuncids_walker(Node *node, void *context);
-static bool planstate_walk_subplans(List *plans, bool (*walker) (),
+static bool planstate_walk_subplans(List *plans,
+ planstate_tree_walker_callback walker,
void *context);
static bool planstate_walk_members(PlanState **planstates, int nplans,
- bool (*walker) (), void *context);
+ planstate_tree_walker_callback walker,
+ void *context);
/*
@@ -1836,7 +1838,7 @@ check_functions_in_node(Node *node, check_function_callback checker,
* that modify nodes in-place but never add/delete/replace nodes).
* A walker routine should look like this:
*
- * bool my_walker (Node *node, my_struct *context)
+ * bool my_walker (Node *node, void *context)
* {
* if (node == NULL)
* return false;
@@ -1850,7 +1852,7 @@ check_functions_in_node(Node *node, check_function_callback checker,
* ... do special actions for other node types
* }
* // for any node type not specially processed, do:
- * return expression_tree_walker(node, my_walker, (void *) context);
+ * return expression_tree_walker(node, my_walker, context);
* }
*
* The "context" argument points to a struct that holds whatever context
@@ -1910,7 +1912,7 @@ check_functions_in_node(Node *node, check_function_callback checker,
bool
expression_tree_walker(Node *node,
- bool (*walker) (),
+ tree_walker_callback walker,
void *context)
{
ListCell *temp;
@@ -1923,6 +1925,10 @@ expression_tree_walker(Node *node,
* when we expect a List we just recurse directly to self without
* bothering to call the walker.
*/
+#define WALK(n) walker((Node *) (n), context)
+
+#define LIST_WALK(l) expression_tree_walker((Node *) (l), walker, context)
+
if (node == NULL)
return false;
@@ -1946,25 +1952,21 @@ expression_tree_walker(Node *node,
/* primitive node types with no expression subnodes */
break;
case T_WithCheckOption:
- return walker(((WithCheckOption *) node)->qual, context);
+ return WALK(((WithCheckOption *) node)->qual);
case T_Aggref:
{
Aggref *expr = (Aggref *) node;
- /* recurse directly on List */
- if (expression_tree_walker((Node *) expr->aggdirectargs,
- walker, context))
+ /* recurse directly on Lists */
+ if (LIST_WALK(expr->aggdirectargs))
return true;
- if (expression_tree_walker((Node *) expr->args,
- walker, context))
+ if (LIST_WALK(expr->args))
return true;
- if (expression_tree_walker((Node *) expr->aggorder,
- walker, context))
+ if (LIST_WALK(expr->aggorder))
return true;
- if (expression_tree_walker((Node *) expr->aggdistinct,
- walker, context))
+ if (LIST_WALK(expr->aggdistinct))
return true;
- if (walker((Node *) expr->aggfilter, context))
+ if (WALK(expr->aggfilter))
return true;
}
break;
@@ -1972,8 +1974,7 @@ expression_tree_walker(Node *node,
{
GroupingFunc *grouping = (GroupingFunc *) node;
- if (expression_tree_walker((Node *) grouping->args,
- walker, context))
+ if (LIST_WALK(grouping->args))
return true;
}
break;
@@ -1982,10 +1983,9 @@ expression_tree_walker(Node *node,
WindowFunc *expr = (WindowFunc *) node;
/* recurse directly on List */
- if (expression_tree_walker((Node *) expr->args,
- walker, context))
+ if (LIST_WALK(expr->args))
return true;
- if (walker((Node *) expr->aggfilter, context))
+ if (WALK(expr->aggfilter))
return true;
}
break;
@@ -1994,17 +1994,15 @@ expression_tree_walker(Node *node,
SubscriptingRef *sbsref = (SubscriptingRef *) node;
/* recurse directly for upper/lower container index lists */
- if (expression_tree_walker((Node *) sbsref->refupperindexpr,
- walker, context))
+ if (LIST_WALK(sbsref->refupperindexpr))
return true;
- if (expression_tree_walker((Node *) sbsref->reflowerindexpr,
- walker, context))
+ if (LIST_WALK(sbsref->reflowerindexpr))
return true;
/* walker must see the refexpr and refassgnexpr, however */
- if (walker(sbsref->refexpr, context))
+ if (WALK(sbsref->refexpr))
return true;
- if (walker(sbsref->refassgnexpr, context))
+ if (WALK(sbsref->refassgnexpr))
return true;
}
break;
@@ -2012,21 +2010,19 @@ expression_tree_walker(Node *node,
{
FuncExpr *expr = (FuncExpr *) node;
- if (expression_tree_walker((Node *) expr->args,
- walker, context))
+ if (LIST_WALK(expr->args))
return true;
}
break;
case T_NamedArgExpr:
- return walker(((NamedArgExpr *) node)->arg, context);
+ return WALK(((NamedArgExpr *) node)->arg);
case T_OpExpr:
case T_DistinctExpr: /* struct-equivalent to OpExpr */
case T_NullIfExpr: /* struct-equivalent to OpExpr */
{
OpExpr *expr = (OpExpr *) node;
- if (expression_tree_walker((Node *) expr->args,
- walker, context))
+ if (LIST_WALK(expr->args))
return true;
}
break;
@@ -2034,8 +2030,7 @@ expression_tree_walker(Node *node,
{
ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;
- if (expression_tree_walker((Node *) expr->args,
- walker, context))
+ if (LIST_WALK(expr->args))
return true;
}
break;
@@ -2043,8 +2038,7 @@ expression_tree_walker(Node *node,
{
BoolExpr *expr = (BoolExpr *) node;
- if (expression_tree_walker((Node *) expr->args,
- walker, context))
+ if (LIST_WALK(expr->args))
return true;
}
break;
@@ -2052,14 +2046,14 @@ expression_tree_walker(Node *node,
{
SubLink *sublink = (SubLink *) node;
- if (walker(sublink->testexpr, context))
+ if (WALK(sublink->testexpr))
return true;
/*
* Also invoke the walker on the sublink's Query node, so it
* can recurse into the sub-query if it wants to.
*/
- return walker(sublink->subselect, context);
+ return WALK(sublink->subselect);
}
break;
case T_SubPlan:
@@ -2067,104 +2061,103 @@ expression_tree_walker(Node *node,
SubPlan *subplan = (SubPlan *) node;
/* recurse into the testexpr, but not into the Plan */
- if (walker(subplan->testexpr, context))
+ if (WALK(subplan->testexpr))
return true;
/* also examine args list */
- if (expression_tree_walker((Node *) subplan->args,
- walker, context))
+ if (LIST_WALK(subplan->args))
return true;
}
break;
case T_AlternativeSubPlan:
- return walker(((AlternativeSubPlan *) node)->subplans, context);
+ return LIST_WALK(((AlternativeSubPlan *) node)->subplans);
case T_FieldSelect:
- return walker(((FieldSelect *) node)->arg, context);
+ return WALK(((FieldSelect *) node)->arg);
case T_FieldStore:
{
FieldStore *fstore = (FieldStore *) node;
- if (walker(fstore->arg, context))
+ if (WALK(fstore->arg))
return true;
- if (walker(fstore->newvals, context))
+ if (WALK(fstore->newvals))
return true;
}
break;
case T_RelabelType:
- return walker(((RelabelType *) node)->arg, context);
+ return WALK(((RelabelType *) node)->arg);
case T_CoerceViaIO:
- return walker(((CoerceViaIO *) node)->arg, context);
+ return WALK(((CoerceViaIO *) node)->arg);
case T_ArrayCoerceExpr:
{
ArrayCoerceExpr *acoerce = (ArrayCoerceExpr *) node;
- if (walker(acoerce->arg, context))
+ if (WALK(acoerce->arg))
return true;
- if (walker(acoerce->elemexpr, context))
+ if (WALK(acoerce->elemexpr))
return true;
}
break;
case T_ConvertRowtypeExpr:
- return walker(((ConvertRowtypeExpr *) node)->arg, context);
+ return WALK(((ConvertRowtypeExpr *) node)->arg);
case T_CollateExpr:
- return walker(((CollateExpr *) node)->arg, context);
+ return WALK(((CollateExpr *) node)->arg);
case T_CaseExpr:
{
CaseExpr *caseexpr = (CaseExpr *) node;
- if (walker(caseexpr->arg, context))
+ if (WALK(caseexpr->arg))
return true;
/* we assume walker doesn't care about CaseWhens, either */
foreach(temp, caseexpr->args)
{
CaseWhen *when = lfirst_node(CaseWhen, temp);
- if (walker(when->expr, context))
+ if (WALK(when->expr))
return true;
- if (walker(when->result, context))
+ if (WALK(when->result))
return true;
}
- if (walker(caseexpr->defresult, context))
+ if (WALK(caseexpr->defresult))
return true;
}
break;
case T_ArrayExpr:
- return walker(((ArrayExpr *) node)->elements, context);
+ return WALK(((ArrayExpr *) node)->elements);
case T_RowExpr:
/* Assume colnames isn't interesting */
- return walker(((RowExpr *) node)->args, context);
+ return WALK(((RowExpr *) node)->args);
case T_RowCompareExpr:
{
RowCompareExpr *rcexpr = (RowCompareExpr *) node;
- if (walker(rcexpr->largs, context))
+ if (WALK(rcexpr->largs))
return true;
- if (walker(rcexpr->rargs, context))
+ if (WALK(rcexpr->rargs))
return true;
}
break;
case T_CoalesceExpr:
- return walker(((CoalesceExpr *) node)->args, context);
+ return WALK(((CoalesceExpr *) node)->args);
case T_MinMaxExpr:
- return walker(((MinMaxExpr *) node)->args, context);
+ return WALK(((MinMaxExpr *) node)->args);
case T_XmlExpr:
{
XmlExpr *xexpr = (XmlExpr *) node;
- if (walker(xexpr->named_args, context))
+ if (WALK(xexpr->named_args))
return true;
/* we assume walker doesn't care about arg_names */
- if (walker(xexpr->args, context))
+ if (WALK(xexpr->args))
return true;
}
break;
case T_NullTest:
- return walker(((NullTest *) node)->arg, context);
+ return WALK(((NullTest *) node)->arg);
case T_BooleanTest:
- return walker(((BooleanTest *) node)->arg, context);
+ return WALK(((BooleanTest *) node)->arg);
case T_CoerceToDomain:
- return walker(((CoerceToDomain *) node)->arg, context);
+ return WALK(((CoerceToDomain *) node)->arg);
case T_TargetEntry:
- return walker(((TargetEntry *) node)->expr, context);
+ return WALK(((TargetEntry *) node)->expr);
case T_Query:
/* Do nothing with a sub-Query, per discussion above */
break;
@@ -2172,13 +2165,13 @@ expression_tree_walker(Node *node,
{
WindowClause *wc = (WindowClause *) node;
- if (walker(wc->partitionClause, context))
+ if (WALK(wc->partitionClause))
return true;
- if (walker(wc->orderClause, context))
+ if (WALK(wc->orderClause))
return true;
- if (walker(wc->startOffset, context))
+ if (WALK(wc->startOffset))
return true;
- if (walker(wc->endOffset, context))
+ if (WALK(wc->endOffset))
return true;
}
break;
@@ -2186,9 +2179,9 @@ expression_tree_walker(Node *node,
{
CTECycleClause *cc = (CTECycleClause *) node;
- if (walker(cc->cycle_mark_value, context))
+ if (WALK(cc->cycle_mark_value))
return true;
- if (walker(cc->cycle_mark_default, context))
+ if (WALK(cc->cycle_mark_default))
return true;
}
break;
@@ -2200,12 +2193,12 @@ expression_tree_walker(Node *node,
* Invoke the walker on the CTE's Query node, so it can
* recurse into the sub-query if it wants to.
*/
- if (walker(cte->ctequery, context))
+ if (WALK(cte->ctequery))
return true;
- if (walker(cte->search_clause, context))
+ if (WALK(cte->search_clause))
return true;
- if (walker(cte->cycle_clause, context))
+ if (WALK(cte->cycle_clause))
return true;
}
break;
@@ -2213,11 +2206,11 @@ expression_tree_walker(Node *node,
{
PartitionBoundSpec *pbs = (PartitionBoundSpec *) node;
- if (walker(pbs->listdatums, context))
+ if (WALK(pbs->listdatums))
return true;
- if (walker(pbs->lowerdatums, context))
+ if (WALK(pbs->lowerdatums))
return true;
- if (walker(pbs->upperdatums, context))
+ if (WALK(pbs->upperdatums))
return true;
}
break;
@@ -2225,14 +2218,14 @@ expression_tree_walker(Node *node,
{
PartitionRangeDatum *prd = (PartitionRangeDatum *) node;
- if (walker(prd->value, context))
+ if (WALK(prd->value))
return true;
}
break;
case T_List:
foreach(temp, (List *) node)
{
- if (walker((Node *) lfirst(temp), context))
+ if (WALK(lfirst(temp)))
return true;
}
break;
@@ -2240,9 +2233,9 @@ expression_tree_walker(Node *node,
{
FromExpr *from = (FromExpr *) node;
- if (walker(from->fromlist, context))
+ if (LIST_WALK(from->fromlist))
return true;
- if (walker(from->quals, context))
+ if (WALK(from->quals))
return true;
}
break;
@@ -2250,15 +2243,15 @@ expression_tree_walker(Node *node,
{
OnConflictExpr *onconflict = (OnConflictExpr *) node;
- if (walker((Node *) onconflict->arbiterElems, context))
+ if (WALK(onconflict->arbiterElems))
return true;
- if (walker(onconflict->arbiterWhere, context))
+ if (WALK(onconflict->arbiterWhere))
return true;
- if (walker(onconflict->onConflictSet, context))
+ if (WALK(onconflict->onConflictSet))
return true;
- if (walker(onconflict->onConflictWhere, context))
+ if (WALK(onconflict->onConflictWhere))
return true;
- if (walker(onconflict->exclRelTlist, context))
+ if (WALK(onconflict->exclRelTlist))
return true;
}
break;
@@ -2266,9 +2259,9 @@ expression_tree_walker(Node *node,
{
MergeAction *action = (MergeAction *) node;
- if (walker(action->targetList, context))
+ if (WALK(action->targetList))
return true;
- if (walker(action->qual, context))
+ if (WALK(action->qual))
return true;
}
break;
@@ -2276,7 +2269,7 @@ expression_tree_walker(Node *node,
{
PartitionPruneStepOp *opstep = (PartitionPruneStepOp *) node;
- if (walker((Node *) opstep->exprs, context))
+ if (WALK(opstep->exprs))
return true;
}
break;
@@ -2287,11 +2280,11 @@ expression_tree_walker(Node *node,
{
JoinExpr *join = (JoinExpr *) node;
- if (walker(join->larg, context))
+ if (WALK(join->larg))
return true;
- if (walker(join->rarg, context))
+ if (WALK(join->rarg))
return true;
- if (walker(join->quals, context))
+ if (WALK(join->quals))
return true;
/*
@@ -2303,9 +2296,9 @@ expression_tree_walker(Node *node,
{
SetOperationStmt *setop = (SetOperationStmt *) node;
- if (walker(setop->larg, context))
+ if (WALK(setop->larg))
return true;
- if (walker(setop->rarg, context))
+ if (WALK(setop->rarg))
return true;
/* groupClauses are deemed uninteresting */
@@ -2315,38 +2308,35 @@ expression_tree_walker(Node *node,
{
IndexClause *iclause = (IndexClause *) node;
- if (walker(iclause->rinfo, context))
+ if (WALK(iclause->rinfo))
return true;
- if (expression_tree_walker((Node *) iclause->indexquals,
- walker, context))
+ if (LIST_WALK(iclause->indexquals))
return true;
}
break;
case T_PlaceHolderVar:
- return walker(((PlaceHolderVar *) node)->phexpr, context);
+ return WALK(((PlaceHolderVar *) node)->phexpr);
case T_InferenceElem:
- return walker(((InferenceElem *) node)->expr, context);
+ return WALK(((InferenceElem *) node)->expr);
case T_AppendRelInfo:
{
AppendRelInfo *appinfo = (AppendRelInfo *) node;
- if (expression_tree_walker((Node *) appinfo->translated_vars,
- walker, context))
+ if (LIST_WALK(appinfo->translated_vars))
return true;
}
break;
case T_PlaceHolderInfo:
- return walker(((PlaceHolderInfo *) node)->ph_var, context);
+ return WALK(((PlaceHolderInfo *) node)->ph_var);
case T_RangeTblFunction:
- return walker(((RangeTblFunction *) node)->funcexpr, context);
+ return WALK(((RangeTblFunction *) node)->funcexpr);
case T_TableSampleClause:
{
TableSampleClause *tsc = (TableSampleClause *) node;
- if (expression_tree_walker((Node *) tsc->args,
- walker, context))
+ if (LIST_WALK(tsc->args))
return true;
- if (walker((Node *) tsc->repeatable, context))
+ if (WALK(tsc->repeatable))
return true;
}
break;
@@ -2354,15 +2344,15 @@ expression_tree_walker(Node *node,
{
TableFunc *tf = (TableFunc *) node;
- if (walker(tf->ns_uris, context))
+ if (WALK(tf->ns_uris))
return true;
- if (walker(tf->docexpr, context))
+ if (WALK(tf->docexpr))
return true;
- if (walker(tf->rowexpr, context))
+ if (WALK(tf->rowexpr))
return true;
- if (walker(tf->colexprs, context))
+ if (WALK(tf->colexprs))
return true;
- if (walker(tf->coldefexprs, context))
+ if (WALK(tf->coldefexprs))
return true;
}
break;
@@ -2372,6 +2362,9 @@ expression_tree_walker(Node *node,
break;
}
return false;
+
+ /* The WALK() macro can be re-used below, but LIST_WALK() not so much */
+#undef LIST_WALK
}
/*
@@ -2391,7 +2384,7 @@ expression_tree_walker(Node *node,
*/
bool
query_tree_walker(Query *query,
- bool (*walker) (),
+ tree_walker_callback walker,
void *context,
int flags)
{
@@ -2404,25 +2397,25 @@ query_tree_walker(Query *query,
* in a rule action.
*/
- if (walker((Node *) query->targetList, context))
+ if (WALK(query->targetList))
return true;
- if (walker((Node *) query->withCheckOptions, context))
+ if (WALK(query->withCheckOptions))
return true;
- if (walker((Node *) query->onConflict, context))
+ if (WALK(query->onConflict))
return true;
- if (walker((Node *) query->mergeActionList, context))
+ if (WALK(query->mergeActionList))
return true;
- if (walker((Node *) query->returningList, context))
+ if (WALK(query->returningList))
return true;
- if (walker((Node *) query->jointree, context))
+ if (WALK(query->jointree))
return true;
- if (walker(query->setOperations, context))
+ if (WALK(query->setOperations))
return true;
- if (walker(query->havingQual, context))
+ if (WALK(query->havingQual))
return true;
- if (walker(query->limitOffset, context))
+ if (WALK(query->limitOffset))
return true;
- if (walker(query->limitCount, context))
+ if (WALK(query->limitCount))
return true;
/*
@@ -2432,13 +2425,13 @@ query_tree_walker(Query *query,
*/
if ((flags & QTW_EXAMINE_SORTGROUP))
{
- if (walker((Node *) query->groupClause, context))
+ if (WALK(query->groupClause))
return true;
- if (walker((Node *) query->windowClause, context))
+ if (WALK(query->windowClause))
return true;
- if (walker((Node *) query->sortClause, context))
+ if (WALK(query->sortClause))
return true;
- if (walker((Node *) query->distinctClause, context))
+ if (WALK(query->distinctClause))
return true;
}
else
@@ -2453,9 +2446,9 @@ query_tree_walker(Query *query,
{
WindowClause *wc = lfirst_node(WindowClause, lc);
- if (walker(wc->startOffset, context))
+ if (WALK(wc->startOffset))
return true;
- if (walker(wc->endOffset, context))
+ if (WALK(wc->endOffset))
return true;
}
}
@@ -2474,7 +2467,7 @@ query_tree_walker(Query *query,
if (!(flags & QTW_IGNORE_CTE_SUBQUERIES))
{
- if (walker((Node *) query->cteList, context))
+ if (WALK(query->cteList))
return true;
}
if (!(flags & QTW_IGNORE_RANGE_TABLE))
@@ -2492,7 +2485,7 @@ query_tree_walker(Query *query,
*/
bool
range_table_walker(List *rtable,
- bool (*walker) (),
+ tree_walker_callback walker,
void *context,
int flags)
{
@@ -2513,7 +2506,7 @@ range_table_walker(List *rtable,
*/
bool
range_table_entry_walker(RangeTblEntry *rte,
- bool (*walker) (),
+ tree_walker_callback walker,
void *context,
int flags)
{
@@ -2523,35 +2516,35 @@ range_table_entry_walker(RangeTblEntry *rte,
* specify neither flag, the walker won't be called on the RTE at all.
*/
if (flags & QTW_EXAMINE_RTES_BEFORE)
- if (walker(rte, context))
+ if (WALK(rte))
return true;
switch (rte->rtekind)
{
case RTE_RELATION:
- if (walker(rte->tablesample, context))
+ if (WALK(rte->tablesample))
return true;
break;
case RTE_SUBQUERY:
if (!(flags & QTW_IGNORE_RT_SUBQUERIES))
- if (walker(rte->subquery, context))
+ if (WALK(rte->subquery))
return true;
break;
case RTE_JOIN:
if (!(flags & QTW_IGNORE_JOINALIASES))
- if (walker(rte->joinaliasvars, context))
+ if (WALK(rte->joinaliasvars))
return true;
break;
case RTE_FUNCTION:
- if (walker(rte->functions, context))
+ if (WALK(rte->functions))
return true;
break;
case RTE_TABLEFUNC:
- if (walker(rte->tablefunc, context))
+ if (WALK(rte->tablefunc))
return true;
break;
case RTE_VALUES:
- if (walker(rte->values_lists, context))
+ if (WALK(rte->values_lists))
return true;
break;
case RTE_CTE:
@@ -2561,11 +2554,11 @@ range_table_entry_walker(RangeTblEntry *rte,
break;
}
- if (walker(rte->securityQuals, context))
+ if (WALK(rte->securityQuals))
return true;
if (flags & QTW_EXAMINE_RTES_AFTER)
- if (walker(rte, context))
+ if (WALK(rte))
return true;
return false;
@@ -2580,7 +2573,7 @@ range_table_entry_walker(RangeTblEntry *rte,
* (or appropriately modified substitute for) the subtree it is handed.
* A mutator routine should look like this:
*
- * Node * my_mutator (Node *node, my_struct *context)
+ * Node * my_mutator (Node *node, void *context)
* {
* if (node == NULL)
* return NULL;
@@ -2594,7 +2587,7 @@ range_table_entry_walker(RangeTblEntry *rte,
* ... do special transformations of other node types
* }
* // for any node type not specially processed, do:
- * return expression_tree_mutator(node, my_mutator, (void *) context);
+ * return expression_tree_mutator(node, my_mutator, context);
* }
*
* The "context" argument points to a struct that holds whatever context
@@ -2636,7 +2629,7 @@ range_table_entry_walker(RangeTblEntry *rte,
Node *
expression_tree_mutator(Node *node,
- Node *(*mutator) (),
+ tree_mutator_callback mutator,
void *context)
{
/*
@@ -3367,7 +3360,7 @@ expression_tree_mutator(Node *node,
*/
Query *
query_tree_mutator(Query *query,
- Node *(*mutator) (),
+ tree_mutator_callback mutator,
void *context,
int flags)
{
@@ -3457,7 +3450,7 @@ query_tree_mutator(Query *query,
*/
List *
range_table_mutator(List *rtable,
- Node *(*mutator) (),
+ tree_mutator_callback mutator,
void *context,
int flags)
{
@@ -3526,7 +3519,7 @@ range_table_mutator(List *rtable,
*/
bool
query_or_expression_tree_walker(Node *node,
- bool (*walker) (),
+ tree_walker_callback walker,
void *context,
int flags)
{
@@ -3536,7 +3529,7 @@ query_or_expression_tree_walker(Node *node,
context,
flags);
else
- return walker(node, context);
+ return WALK(node);
}
/*
@@ -3549,7 +3542,7 @@ query_or_expression_tree_walker(Node *node,
*/
Node *
query_or_expression_tree_mutator(Node *node,
- Node *(*mutator) (),
+ tree_mutator_callback mutator,
void *context,
int flags)
{
@@ -3580,7 +3573,7 @@ query_or_expression_tree_mutator(Node *node,
*/
bool
raw_expression_tree_walker(Node *node,
- bool (*walker) (),
+ tree_walker_callback walker,
void *context)
{
ListCell *temp;
@@ -3614,17 +3607,17 @@ raw_expression_tree_walker(Node *node,
/* we assume the colnames list isn't interesting */
break;
case T_RangeVar:
- return walker(((RangeVar *) node)->alias, context);
+ return WALK(((RangeVar *) node)->alias);
case T_GroupingFunc:
- return walker(((GroupingFunc *) node)->args, context);
+ return WALK(((GroupingFunc *) node)->args);
case T_SubLink:
{
SubLink *sublink = (SubLink *) node;
- if (walker(sublink->testexpr, context))
+ if (WALK(sublink->testexpr))
return true;
/* we assume the operName is not interesting */
- if (walker(sublink->subselect, context))
+ if (WALK(sublink->subselect))
return true;
}
break;
@@ -3632,55 +3625,55 @@ raw_expression_tree_walker(Node *node,
{
CaseExpr *caseexpr = (CaseExpr *) node;
- if (walker(caseexpr->arg, context))
+ if (WALK(caseexpr->arg))
return true;
/* we assume walker doesn't care about CaseWhens, either */
foreach(temp, caseexpr->args)
{
CaseWhen *when = lfirst_node(CaseWhen, temp);
- if (walker(when->expr, context))
+ if (WALK(when->expr))
return true;
- if (walker(when->result, context))
+ if (WALK(when->result))
return true;
}
- if (walker(caseexpr->defresult, context))
+ if (WALK(caseexpr->defresult))
return true;
}
break;
case T_RowExpr:
/* Assume colnames isn't interesting */
- return walker(((RowExpr *) node)->args, context);
+ return WALK(((RowExpr *) node)->args);
case T_CoalesceExpr:
- return walker(((CoalesceExpr *) node)->args, context);
+ return WALK(((CoalesceExpr *) node)->args);
case T_MinMaxExpr:
- return walker(((MinMaxExpr *) node)->args, context);
+ return WALK(((MinMaxExpr *) node)->args);
case T_XmlExpr:
{
XmlExpr *xexpr = (XmlExpr *) node;
- if (walker(xexpr->named_args, context))
+ if (WALK(xexpr->named_args))
return true;
/* we assume walker doesn't care about arg_names */
- if (walker(xexpr->args, context))
+ if (WALK(xexpr->args))
return true;
}
break;
case T_NullTest:
- return walker(((NullTest *) node)->arg, context);
+ return WALK(((NullTest *) node)->arg);
case T_BooleanTest:
- return walker(((BooleanTest *) node)->arg, context);
+ return WALK(((BooleanTest *) node)->arg);
case T_JoinExpr:
{
JoinExpr *join = (JoinExpr *) node;
- if (walker(join->larg, context))
+ if (WALK(join->larg))
return true;
- if (walker(join->rarg, context))
+ if (WALK(join->rarg))
return true;
- if (walker(join->quals, context))
+ if (WALK(join->quals))
return true;
- if (walker(join->alias, context))
+ if (WALK(join->alias))
return true;
/* using list is deemed uninteresting */
}
@@ -3689,18 +3682,18 @@ raw_expression_tree_walker(Node *node,
{
IntoClause *into = (IntoClause *) node;
- if (walker(into->rel, context))
+ if (WALK(into->rel))
return true;
/* colNames, options are deemed uninteresting */
/* viewQuery should be null in raw parsetree, but check it */
- if (walker(into->viewQuery, context))
+ if (WALK(into->viewQuery))
return true;
}
break;
case T_List:
foreach(temp, (List *) node)
{
- if (walker((Node *) lfirst(temp), context))
+ if (WALK((Node *) lfirst(temp)))
return true;
}
break;
@@ -3708,17 +3701,17 @@ raw_expression_tree_walker(Node *node,
{
InsertStmt *stmt = (InsertStmt *) node;
- if (walker(stmt->relation, context))
+ if (WALK(stmt->relation))
return true;
- if (walker(stmt->cols, context))
+ if (WALK(stmt->cols))
return true;
- if (walker(stmt->selectStmt, context))
+ if (WALK(stmt->selectStmt))
return true;
- if (walker(stmt->onConflictClause, context))
+ if (WALK(stmt->onConflictClause))
return true;
- if (walker(stmt->returningList, context))
+ if (WALK(stmt->returningList))
return true;
- if (walker(stmt->withClause, context))
+ if (WALK(stmt->withClause))
return true;
}
break;
@@ -3726,15 +3719,15 @@ raw_expression_tree_walker(Node *node,
{
DeleteStmt *stmt = (DeleteStmt *) node;
- if (walker(stmt->relation, context))
+ if (WALK(stmt->relation))
return true;
- if (walker(stmt->usingClause, context))
+ if (WALK(stmt->usingClause))
return true;
- if (walker(stmt->whereClause, context))
+ if (WALK(stmt->whereClause))
return true;
- if (walker(stmt->returningList, context))
+ if (WALK(stmt->returningList))
return true;
- if (walker(stmt->withClause, context))
+ if (WALK(stmt->withClause))
return true;
}
break;
@@ -3742,17 +3735,17 @@ raw_expression_tree_walker(Node *node,
{
UpdateStmt *stmt = (UpdateStmt *) node;
- if (walker(stmt->relation, context))
+ if (WALK(stmt->relation))
return true;
- if (walker(stmt->targetList, context))
+ if (WALK(stmt->targetList))
return true;
- if (walker(stmt->whereClause, context))
+ if (WALK(stmt->whereClause))
return true;
- if (walker(stmt->fromClause, context))
+ if (WALK(stmt->fromClause))
return true;
- if (walker(stmt->returningList, context))
+ if (WALK(stmt->returningList))
return true;
- if (walker(stmt->withClause, context))
+ if (WALK(stmt->withClause))
return true;
}
break;
@@ -3760,15 +3753,15 @@ raw_expression_tree_walker(Node *node,
{
MergeStmt *stmt = (MergeStmt *) node;
- if (walker(stmt->relation, context))
+ if (WALK(stmt->relation))
return true;
- if (walker(stmt->sourceRelation, context))
+ if (WALK(stmt->sourceRelation))
return true;
- if (walker(stmt->joinCondition, context))
+ if (WALK(stmt->joinCondition))
return true;
- if (walker(stmt->mergeWhenClauses, context))
+ if (WALK(stmt->mergeWhenClauses))
return true;
- if (walker(stmt->withClause, context))
+ if (WALK(stmt->withClause))
return true;
}
break;
@@ -3776,11 +3769,11 @@ raw_expression_tree_walker(Node *node,
{
MergeWhenClause *mergeWhenClause = (MergeWhenClause *) node;
- if (walker(mergeWhenClause->condition, context))
+ if (WALK(mergeWhenClause->condition))
return true;
- if (walker(mergeWhenClause->targetList, context))
+ if (WALK(mergeWhenClause->targetList))
return true;
- if (walker(mergeWhenClause->values, context))
+ if (WALK(mergeWhenClause->values))
return true;
}
break;
@@ -3788,37 +3781,37 @@ raw_expression_tree_walker(Node *node,
{
SelectStmt *stmt = (SelectStmt *) node;
- if (walker(stmt->distinctClause, context))
+ if (WALK(stmt->distinctClause))
return true;
- if (walker(stmt->intoClause, context))
+ if (WALK(stmt->intoClause))
return true;
- if (walker(stmt->targetList, context))
+ if (WALK(stmt->targetList))
return true;
- if (walker(stmt->fromClause, context))
+ if (WALK(stmt->fromClause))
return true;
- if (walker(stmt->whereClause, context))
+ if (WALK(stmt->whereClause))
return true;
- if (walker(stmt->groupClause, context))
+ if (WALK(stmt->groupClause))
return true;
- if (walker(stmt->havingClause, context))
+ if (WALK(stmt->havingClause))
return true;
- if (walker(stmt->windowClause, context))
+ if (WALK(stmt->windowClause))
return true;
- if (walker(stmt->valuesLists, context))
+ if (WALK(stmt->valuesLists))
return true;
- if (walker(stmt->sortClause, context))
+ if (WALK(stmt->sortClause))
return true;
- if (walker(stmt->limitOffset, context))
+ if (WALK(stmt->limitOffset))
return true;
- if (walker(stmt->limitCount, context))
+ if (WALK(stmt->limitCount))
return true;
- if (walker(stmt->lockingClause, context))
+ if (WALK(stmt->lockingClause))
return true;
- if (walker(stmt->withClause, context))
+ if (WALK(stmt->withClause))
return true;
- if (walker(stmt->larg, context))
+ if (WALK(stmt->larg))
return true;
- if (walker(stmt->rarg, context))
+ if (WALK(stmt->rarg))
return true;
}
break;
@@ -3826,9 +3819,9 @@ raw_expression_tree_walker(Node *node,
{
PLAssignStmt *stmt = (PLAssignStmt *) node;
- if (walker(stmt->indirection, context))
+ if (WALK(stmt->indirection))
return true;
- if (walker(stmt->val, context))
+ if (WALK(stmt->val))
return true;
}
break;
@@ -3836,9 +3829,9 @@ raw_expression_tree_walker(Node *node,
{
A_Expr *expr = (A_Expr *) node;
- if (walker(expr->lexpr, context))
+ if (WALK(expr->lexpr))
return true;
- if (walker(expr->rexpr, context))
+ if (WALK(expr->rexpr))
return true;
/* operator name is deemed uninteresting */
}
@@ -3847,7 +3840,7 @@ raw_expression_tree_walker(Node *node,
{
BoolExpr *expr = (BoolExpr *) node;
- if (walker(expr->args, context))
+ if (WALK(expr->args))
return true;
}
break;
@@ -3858,26 +3851,26 @@ raw_expression_tree_walker(Node *node,
{
FuncCall *fcall = (FuncCall *) node;
- if (walker(fcall->args, context))
+ if (WALK(fcall->args))
return true;
- if (walker(fcall->agg_order, context))
+ if (WALK(fcall->agg_order))
return true;
- if (walker(fcall->agg_filter, context))
+ if (WALK(fcall->agg_filter))
return true;
- if (walker(fcall->over, context))
+ if (WALK(fcall->over))
return true;
/* function name is deemed uninteresting */
}
break;
case T_NamedArgExpr:
- return walker(((NamedArgExpr *) node)->arg, context);
+ return WALK(((NamedArgExpr *) node)->arg);
case T_A_Indices:
{
A_Indices *indices = (A_Indices *) node;
- if (walker(indices->lidx, context))
+ if (WALK(indices->lidx))
return true;
- if (walker(indices->uidx, context))
+ if (WALK(indices->uidx))
return true;
}
break;
@@ -3885,51 +3878,51 @@ raw_expression_tree_walker(Node *node,
{
A_Indirection *indir = (A_Indirection *) node;
- if (walker(indir->arg, context))
+ if (WALK(indir->arg))
return true;
- if (walker(indir->indirection, context))
+ if (WALK(indir->indirection))
return true;
}
break;
case T_A_ArrayExpr:
- return walker(((A_ArrayExpr *) node)->elements, context);
+ return WALK(((A_ArrayExpr *) node)->elements);
case T_ResTarget:
{
ResTarget *rt = (ResTarget *) node;
- if (walker(rt->indirection, context))
+ if (WALK(rt->indirection))
return true;
- if (walker(rt->val, context))
+ if (WALK(rt->val))
return true;
}
break;
case T_MultiAssignRef:
- return walker(((MultiAssignRef *) node)->source, context);
+ return WALK(((MultiAssignRef *) node)->source);
case T_TypeCast:
{
TypeCast *tc = (TypeCast *) node;
- if (walker(tc->arg, context))
+ if (WALK(tc->arg))
return true;
- if (walker(tc->typeName, context))
+ if (WALK(tc->typeName))
return true;
}
break;
case T_CollateClause:
- return walker(((CollateClause *) node)->arg, context);
+ return WALK(((CollateClause *) node)->arg);
case T_SortBy:
- return walker(((SortBy *) node)->node, context);
+ return WALK(((SortBy *) node)->node);
case T_WindowDef:
{
WindowDef *wd = (WindowDef *) node;
- if (walker(wd->partitionClause, context))
+ if (WALK(wd->partitionClause))
return true;
- if (walker(wd->orderClause, context))
+ if (WALK(wd->orderClause))
return true;
- if (walker(wd->startOffset, context))
+ if (WALK(wd->startOffset))
return true;
- if (walker(wd->endOffset, context))
+ if (WALK(wd->endOffset))
return true;
}
break;
@@ -3937,9 +3930,9 @@ raw_expression_tree_walker(Node *node,
{
RangeSubselect *rs = (RangeSubselect *) node;
- if (walker(rs->subquery, context))
+ if (WALK(rs->subquery))
return true;
- if (walker(rs->alias, context))
+ if (WALK(rs->alias))
return true;
}
break;
@@ -3947,11 +3940,11 @@ raw_expression_tree_walker(Node *node,
{
RangeFunction *rf = (RangeFunction *) node;
- if (walker(rf->functions, context))
+ if (WALK(rf->functions))
return true;
- if (walker(rf->alias, context))
+ if (WALK(rf->alias))
return true;
- if (walker(rf->coldeflist, context))
+ if (WALK(rf->coldeflist))
return true;
}
break;
@@ -3959,12 +3952,12 @@ raw_expression_tree_walker(Node *node,
{
RangeTableSample *rts = (RangeTableSample *) node;
- if (walker(rts->relation, context))
+ if (WALK(rts->relation))
return true;
/* method name is deemed uninteresting */
- if (walker(rts->args, context))
+ if (WALK(rts->args))
return true;
- if (walker(rts->repeatable, context))
+ if (WALK(rts->repeatable))
return true;
}
break;
@@ -3972,15 +3965,15 @@ raw_expression_tree_walker(Node *node,
{
RangeTableFunc *rtf = (RangeTableFunc *) node;
- if (walker(rtf->docexpr, context))
+ if (WALK(rtf->docexpr))
return true;
- if (walker(rtf->rowexpr, context))
+ if (WALK(rtf->rowexpr))
return true;
- if (walker(rtf->namespaces, context))
+ if (WALK(rtf->namespaces))
return true;
- if (walker(rtf->columns, context))
+ if (WALK(rtf->columns))
return true;
- if (walker(rtf->alias, context))
+ if (WALK(rtf->alias))
return true;
}
break;
@@ -3988,9 +3981,9 @@ raw_expression_tree_walker(Node *node,
{
RangeTableFuncCol *rtfc = (RangeTableFuncCol *) node;
- if (walker(rtfc->colexpr, context))
+ if (WALK(rtfc->colexpr))
return true;
- if (walker(rtfc->coldefexpr, context))
+ if (WALK(rtfc->coldefexpr))
return true;
}
break;
@@ -3998,9 +3991,9 @@ raw_expression_tree_walker(Node *node,
{
TypeName *tn = (TypeName *) node;
- if (walker(tn->typmods, context))
+ if (WALK(tn->typmods))
return true;
- if (walker(tn->arrayBounds, context))
+ if (WALK(tn->arrayBounds))
return true;
/* type name itself is deemed uninteresting */
}
@@ -4009,13 +4002,13 @@ raw_expression_tree_walker(Node *node,
{
ColumnDef *coldef = (ColumnDef *) node;
- if (walker(coldef->typeName, context))
+ if (WALK(coldef->typeName))
return true;
- if (walker(coldef->compression, context))
+ if (WALK(coldef->compression))
return true;
- if (walker(coldef->raw_default, context))
+ if (WALK(coldef->raw_default))
return true;
- if (walker(coldef->collClause, context))
+ if (WALK(coldef->collClause))
return true;
/* for now, constraints are ignored */
}
@@ -4024,34 +4017,34 @@ raw_expression_tree_walker(Node *node,
{
IndexElem *indelem = (IndexElem *) node;
- if (walker(indelem->expr, context))
+ if (WALK(indelem->expr))
return true;
/* collation and opclass names are deemed uninteresting */
}
break;
case T_GroupingSet:
- return walker(((GroupingSet *) node)->content, context);
+ return WALK(((GroupingSet *) node)->content);
case T_LockingClause:
- return walker(((LockingClause *) node)->lockedRels, context);
+ return WALK(((LockingClause *) node)->lockedRels);
case T_XmlSerialize:
{
XmlSerialize *xs = (XmlSerialize *) node;
- if (walker(xs->expr, context))
+ if (WALK(xs->expr))
return true;
- if (walker(xs->typeName, context))
+ if (WALK(xs->typeName))
return true;
}
break;
case T_WithClause:
- return walker(((WithClause *) node)->ctes, context);
+ return WALK(((WithClause *) node)->ctes);
case T_InferClause:
{
InferClause *stmt = (InferClause *) node;
- if (walker(stmt->indexElems, context))
+ if (WALK(stmt->indexElems))
return true;
- if (walker(stmt->whereClause, context))
+ if (WALK(stmt->whereClause))
return true;
}
break;
@@ -4059,17 +4052,17 @@ raw_expression_tree_walker(Node *node,
{
OnConflictClause *stmt = (OnConflictClause *) node;
- if (walker(stmt->infer, context))
+ if (WALK(stmt->infer))
return true;
- if (walker(stmt->targetList, context))
+ if (WALK(stmt->targetList))
return true;
- if (walker(stmt->whereClause, context))
+ if (WALK(stmt->whereClause))
return true;
}
break;
case T_CommonTableExpr:
/* search_clause and cycle_clause are not interesting here */
- return walker(((CommonTableExpr *) node)->ctequery, context);
+ return WALK(((CommonTableExpr *) node)->ctequery);
default:
elog(ERROR, "unrecognized node type: %d",
(int) nodeTag(node));
@@ -4086,12 +4079,15 @@ raw_expression_tree_walker(Node *node,
*/
bool
planstate_tree_walker(PlanState *planstate,
- bool (*walker) (),
+ planstate_tree_walker_callback walker,
void *context)
{
Plan *plan = planstate->plan;
ListCell *lc;
+ /* We don't need implicit coercions to Node here */
+#define PSWALK(n) walker(n, context)
+
/* Guard against stack overflow due to overly complex plan trees */
check_stack_depth();
@@ -4102,14 +4098,14 @@ planstate_tree_walker(PlanState *planstate,
/* lefttree */
if (outerPlanState(planstate))
{
- if (walker(outerPlanState(planstate), context))
+ if (PSWALK(outerPlanState(planstate)))
return true;
}
/* righttree */
if (innerPlanState(planstate))
{
- if (walker(innerPlanState(planstate), context))
+ if (PSWALK(innerPlanState(planstate)))
return true;
}
@@ -4141,13 +4137,13 @@ planstate_tree_walker(PlanState *planstate,
return true;
break;
case T_SubqueryScan:
- if (walker(((SubqueryScanState *) planstate)->subplan, context))
+ if (PSWALK(((SubqueryScanState *) planstate)->subplan))
return true;
break;
case T_CustomScan:
foreach(lc, ((CustomScanState *) planstate)->custom_ps)
{
- if (walker((PlanState *) lfirst(lc), context))
+ if (PSWALK(lfirst(lc)))
return true;
}
break;
@@ -4167,7 +4163,7 @@ planstate_tree_walker(PlanState *planstate,
*/
static bool
planstate_walk_subplans(List *plans,
- bool (*walker) (),
+ planstate_tree_walker_callback walker,
void *context)
{
ListCell *lc;
@@ -4176,7 +4172,7 @@ planstate_walk_subplans(List *plans,
{
SubPlanState *sps = lfirst_node(SubPlanState, lc);
- if (walker(sps->planstate, context))
+ if (PSWALK(sps->planstate))
return true;
}
@@ -4189,13 +4185,14 @@ planstate_walk_subplans(List *plans,
*/
static bool
planstate_walk_members(PlanState **planstates, int nplans,
- bool (*walker) (), void *context)
+ planstate_tree_walker_callback walker,
+ void *context)
{
int j;
for (j = 0; j < nplans; j++)
{
- if (walker(planstates[j], context))
+ if (PSWALK(planstates[j]))
return true;
}
diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c
index f486d42441..1e0d43b183 100644
--- a/src/backend/optimizer/path/costsize.c
+++ b/src/backend/optimizer/path/costsize.c
@@ -165,7 +165,7 @@ static MergeScanSelCache *cached_scansel(PlannerInfo *root,
PathKey *pathkey);
static void cost_rescan(PlannerInfo *root, Path *path,
Cost *rescan_startup_cost, Cost *rescan_total_cost);
-static bool cost_qual_eval_walker(Node *node, cost_qual_eval_context *context);
+static bool cost_qual_eval_walker(Node *node, void *ctx);
static void get_restriction_qual_cost(PlannerInfo *root, RelOptInfo *baserel,
ParamPathInfo *param_info,
QualCost *qpqual_cost);
@@ -4722,8 +4722,10 @@ cost_qual_eval_node(QualCost *cost, Node *qual, PlannerInfo *root)
}
static bool
-cost_qual_eval_walker(Node *node, cost_qual_eval_context *context)
+cost_qual_eval_walker(Node *node, void *ctx)
{
+ cost_qual_eval_context *context = ctx;
+
if (node == NULL)
return false;
@@ -4986,8 +4988,7 @@ cost_qual_eval_walker(Node *node, cost_qual_eval_context *context)
}
/* recurse into children */
- return expression_tree_walker(node, cost_qual_eval_walker,
- (void *) context);
+ return expression_tree_walker(node, cost_qual_eval_walker, ctx);
}
/*
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index cd8a3ef7cb..ed1f25d84b 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -162,7 +162,7 @@ static NestLoop *create_nestloop_plan(PlannerInfo *root, NestPath *best_path);
static MergeJoin *create_mergejoin_plan(PlannerInfo *root, MergePath *best_path);
static HashJoin *create_hashjoin_plan(PlannerInfo *root, HashPath *best_path);
static Node *replace_nestloop_params(PlannerInfo *root, Node *expr);
-static Node *replace_nestloop_params_mutator(Node *node, PlannerInfo *root);
+static Node *replace_nestloop_params_mutator(Node *node, void *ctx);
static void fix_indexqual_references(PlannerInfo *root, IndexPath *index_path,
List **stripped_indexquals_p,
List **fixed_indexquals_p);
@@ -4891,8 +4891,10 @@ replace_nestloop_params(PlannerInfo *root, Node *expr)
}
static Node *
-replace_nestloop_params_mutator(Node *node, PlannerInfo *root)
+replace_nestloop_params_mutator(Node *node, void *ctx)
{
+ PlannerInfo *root = ctx;
+
if (node == NULL)
return NULL;
if (IsA(node, Var))
@@ -4938,16 +4940,13 @@ replace_nestloop_params_mutator(Node *node, PlannerInfo *root)
memcpy(newphv, phv, sizeof(PlaceHolderVar));
newphv->phexpr = (Expr *)
- replace_nestloop_params_mutator((Node *) phv->phexpr,
- root);
+ replace_nestloop_params_mutator((Node *) phv->phexpr, ctx);
return (Node *) newphv;
}
/* Replace the PlaceHolderVar with a nestloop Param */
return (Node *) replace_nestloop_param_placeholdervar(root, phv);
}
- return expression_tree_mutator(node,
- replace_nestloop_params_mutator,
- (void *) root);
+ return expression_tree_mutator(node, replace_nestloop_params_mutator, ctx);
}
/*
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index 1cb0abdbc1..228c15f6e6 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -113,7 +113,7 @@ typedef struct
static void add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing);
static void flatten_unplanned_rtes(PlannerGlobal *glob, RangeTblEntry *rte);
-static bool flatten_rtes_walker(Node *node, PlannerGlobal *glob);
+static bool flatten_rtes_walker(Node *node, void *ctx);
static void add_rte_to_flat_rtable(PlannerGlobal *glob, RangeTblEntry *rte);
static Plan *set_plan_refs(PlannerInfo *root, Plan *plan, int rtoffset);
static Plan *set_indexonlyscan_references(PlannerInfo *root,
@@ -139,8 +139,8 @@ static void set_hash_references(PlannerInfo *root, Plan *plan, int rtoffset);
static Relids offset_relid_set(Relids relids, int rtoffset);
static Node *fix_scan_expr(PlannerInfo *root, Node *node,
int rtoffset, double num_exec);
-static Node *fix_scan_expr_mutator(Node *node, fix_scan_expr_context *context);
-static bool fix_scan_expr_walker(Node *node, fix_scan_expr_context *context);
+static Node *fix_scan_expr_mutator(Node *node, void *ctx);
+static bool fix_scan_expr_walker(Node *node, void *ctx);
static void set_join_references(PlannerInfo *root, Join *join, int rtoffset);
static void set_upper_references(PlannerInfo *root, Plan *plan, int rtoffset);
static void set_param_references(PlannerInfo *root, Plan *plan);
@@ -164,15 +164,13 @@ static List *fix_join_expr(PlannerInfo *root,
indexed_tlist *inner_itlist,
Index acceptable_rel,
int rtoffset, double num_exec);
-static Node *fix_join_expr_mutator(Node *node,
- fix_join_expr_context *context);
+static Node *fix_join_expr_mutator(Node *node, void *ctx);
static Node *fix_upper_expr(PlannerInfo *root,
Node *node,
indexed_tlist *subplan_itlist,
int newvarno,
int rtoffset, double num_exec);
-static Node *fix_upper_expr_mutator(Node *node,
- fix_upper_expr_context *context);
+static Node *fix_upper_expr_mutator(Node *node, void *ctx);
static List *set_returning_clause_references(PlannerInfo *root,
List *rlist,
Plan *topplan,
@@ -453,8 +451,10 @@ flatten_unplanned_rtes(PlannerGlobal *glob, RangeTblEntry *rte)
}
static bool
-flatten_rtes_walker(Node *node, PlannerGlobal *glob)
+flatten_rtes_walker(Node *node, void *ctx)
{
+ PlannerGlobal *glob = ctx;
+
if (node == NULL)
return false;
if (IsA(node, RangeTblEntry))
@@ -471,11 +471,10 @@ flatten_rtes_walker(Node *node, PlannerGlobal *glob)
/* Recurse into subselects */
return query_tree_walker((Query *) node,
flatten_rtes_walker,
- (void *) glob,
+ ctx,
QTW_EXAMINE_RTES_BEFORE);
}
- return expression_tree_walker(node, flatten_rtes_walker,
- (void *) glob);
+ return expression_tree_walker(node, flatten_rtes_walker, ctx);
}
/*
@@ -2055,8 +2054,10 @@ fix_scan_expr(PlannerInfo *root, Node *node, int rtoffset, double num_exec)
}
static Node *
-fix_scan_expr_mutator(Node *node, fix_scan_expr_context *context)
+fix_scan_expr_mutator(Node *node, void *ctx)
{
+ fix_scan_expr_context *context = ctx;
+
if (node == NULL)
return NULL;
if (IsA(node, Var))
@@ -2115,29 +2116,29 @@ fix_scan_expr_mutator(Node *node, fix_scan_expr_context *context)
/* At scan level, we should always just evaluate the contained expr */
PlaceHolderVar *phv = (PlaceHolderVar *) node;
- return fix_scan_expr_mutator((Node *) phv->phexpr, context);
+ return fix_scan_expr_mutator((Node *) phv->phexpr, ctx);
}
if (IsA(node, AlternativeSubPlan))
return fix_scan_expr_mutator(fix_alternative_subplan(context->root,
(AlternativeSubPlan *) node,
context->num_exec),
- context);
+ ctx);
fix_expr_common(context->root, node);
- return expression_tree_mutator(node, fix_scan_expr_mutator,
- (void *) context);
+ return expression_tree_mutator(node, fix_scan_expr_mutator, ctx);
}
static bool
-fix_scan_expr_walker(Node *node, fix_scan_expr_context *context)
+fix_scan_expr_walker(Node *node, void *ctx)
{
+ fix_scan_expr_context *context = ctx;
+
if (node == NULL)
return false;
Assert(!(IsA(node, Var) && ((Var *) node)->varno == ROWID_VAR));
Assert(!IsA(node, PlaceHolderVar));
Assert(!IsA(node, AlternativeSubPlan));
fix_expr_common(context->root, node);
- return expression_tree_walker(node, fix_scan_expr_walker,
- (void *) context);
+ return expression_tree_walker(node, fix_scan_expr_walker, ctx);
}
/*
@@ -2825,8 +2826,9 @@ fix_join_expr(PlannerInfo *root,
}
static Node *
-fix_join_expr_mutator(Node *node, fix_join_expr_context *context)
+fix_join_expr_mutator(Node *node, void *ctx)
{
+ fix_join_expr_context *context = ctx;
Var *newvar;
if (node == NULL)
@@ -2893,7 +2895,7 @@ fix_join_expr_mutator(Node *node, fix_join_expr_context *context)
}
/* If not supplied by input plans, evaluate the contained expr */
- return fix_join_expr_mutator((Node *) phv->phexpr, context);
+ return fix_join_expr_mutator((Node *) phv->phexpr, ctx);
}
/* Try matching more complex expressions too, if tlists have any */
if (context->outer_itlist && context->outer_itlist->has_non_vars)
@@ -2919,11 +2921,9 @@ fix_join_expr_mutator(Node *node, fix_join_expr_context *context)
return fix_join_expr_mutator(fix_alternative_subplan(context->root,
(AlternativeSubPlan *) node,
context->num_exec),
- context);
+ ctx);
fix_expr_common(context->root, node);
- return expression_tree_mutator(node,
- fix_join_expr_mutator,
- (void *) context);
+ return expression_tree_mutator(node, fix_join_expr_mutator, ctx);
}
/*
@@ -2976,8 +2976,9 @@ fix_upper_expr(PlannerInfo *root,
}
static Node *
-fix_upper_expr_mutator(Node *node, fix_upper_expr_context *context)
+fix_upper_expr_mutator(Node *node, void *ctx)
{
+ fix_upper_expr_context *context = ctx;
Var *newvar;
if (node == NULL)
@@ -3008,7 +3009,7 @@ fix_upper_expr_mutator(Node *node, fix_upper_expr_context *context)
return (Node *) newvar;
}
/* If not supplied by input plan, evaluate the contained expr */
- return fix_upper_expr_mutator((Node *) phv->phexpr, context);
+ return fix_upper_expr_mutator((Node *) phv->phexpr, ctx);
}
/* Try matching more complex expressions too, if tlist has any */
if (context->subplan_itlist->has_non_vars)
@@ -3048,11 +3049,9 @@ fix_upper_expr_mutator(Node *node, fix_upper_expr_context *context)
return fix_upper_expr_mutator(fix_alternative_subplan(context->root,
(AlternativeSubPlan *) node,
context->num_exec),
- context);
+ ctx);
fix_expr_common(context->root, node);
- return expression_tree_mutator(node,
- fix_upper_expr_mutator,
- (void *) context);
+ return expression_tree_mutator(node, fix_upper_expr_mutator, ctx);
}
/*
@@ -3127,9 +3126,10 @@ set_returning_clause_references(PlannerInfo *root,
* in the targetlist which references that WindowFunc.
*/
static Node *
-fix_windowagg_condition_expr_mutator(Node *node,
- fix_windowagg_cond_context *context)
+fix_windowagg_condition_expr_mutator(Node *node, void *ctx)
{
+ fix_windowagg_cond_context *context = ctx;
+
if (node == NULL)
return NULL;
@@ -3145,9 +3145,8 @@ fix_windowagg_condition_expr_mutator(Node *node,
elog(ERROR, "WindowFunc not found in subplan target lists");
}
- return expression_tree_mutator(node,
- fix_windowagg_condition_expr_mutator,
- (void *) context);
+ return expression_tree_mutator(node, fix_windowagg_condition_expr_mutator,
+ ctx);
}
/*
@@ -3323,8 +3322,10 @@ extract_query_dependencies(Node *query,
* and invalItems lists are added to as needed.
*/
bool
-extract_query_dependencies_walker(Node *node, PlannerInfo *context)
+extract_query_dependencies_walker(Node *node, void *ctx)
{
+ PlannerInfo *context = ctx;
+
if (node == NULL)
return false;
Assert(!IsA(node, PlaceHolderVar));
@@ -3365,10 +3366,9 @@ extract_query_dependencies_walker(Node *node, PlannerInfo *context)
/* And recurse into the query's subexpressions */
return query_tree_walker(query, extract_query_dependencies_walker,
- (void *) context, 0);
+ ctx, 0);
}
/* Extract function dependencies and check for regclass Consts */
fix_expr_common(context, node);
- return expression_tree_walker(node, extract_query_dependencies_walker,
- (void *) context);
+ return expression_tree_walker(node, extract_query_dependencies_walker, ctx);
}
diff --git a/src/backend/optimizer/plan/subselect.c b/src/backend/optimizer/plan/subselect.c
index 92e3338584..e2785b1fde 100644
--- a/src/backend/optimizer/plan/subselect.c
+++ b/src/backend/optimizer/plan/subselect.c
@@ -77,8 +77,7 @@ static List *generate_subquery_vars(PlannerInfo *root, List *tlist,
static Node *convert_testexpr(PlannerInfo *root,
Node *testexpr,
List *subst_nodes);
-static Node *convert_testexpr_mutator(Node *node,
- convert_testexpr_context *context);
+static Node *convert_testexpr_mutator(Node *node, void *ctx);
static bool subplan_is_hashable(Plan *plan);
static bool subpath_is_hashable(Path *path);
static bool testexpr_is_hashable(Node *testexpr, List *param_ids);
@@ -87,22 +86,21 @@ static bool hash_ok_operator(OpExpr *expr);
static bool contain_dml(Node *node);
static bool contain_dml_walker(Node *node, void *context);
static bool contain_outer_selfref(Node *node);
-static bool contain_outer_selfref_walker(Node *node, Index *depth);
+static bool contain_outer_selfref_walker(Node *node, void *ctx);
static void inline_cte(PlannerInfo *root, CommonTableExpr *cte);
-static bool inline_cte_walker(Node *node, inline_cte_walker_context *context);
+static bool inline_cte_walker(Node *node, void *ctx);
static bool simplify_EXISTS_query(PlannerInfo *root, Query *query);
static Query *convert_EXISTS_to_ANY(PlannerInfo *root, Query *subselect,
Node **testexpr, List **paramIds);
-static Node *replace_correlation_vars_mutator(Node *node, PlannerInfo *root);
-static Node *process_sublinks_mutator(Node *node,
- process_sublinks_context *context);
+static Node *replace_correlation_vars_mutator(Node *node, void *ctx);
+static Node *process_sublinks_mutator(Node *node, void *ctx);
static Bitmapset *finalize_plan(PlannerInfo *root,
Plan *plan,
int gather_param,
Bitmapset *valid_params,
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 bool finalize_primnode(Node *node, void *ctx);
+static bool finalize_agg_primnode(Node *node, void *ctx);
/*
@@ -664,9 +662,10 @@ convert_testexpr(PlannerInfo *root,
}
static Node *
-convert_testexpr_mutator(Node *node,
- convert_testexpr_context *context)
+convert_testexpr_mutator(Node *node, void *ctx)
{
+ convert_testexpr_context *context = ctx;
+
if (node == NULL)
return NULL;
if (IsA(node, Param))
@@ -710,9 +709,7 @@ convert_testexpr_mutator(Node *node,
*/
return node;
}
- return expression_tree_mutator(node,
- convert_testexpr_mutator,
- (void *) context);
+ return expression_tree_mutator(node, convert_testexpr_mutator, ctx);
}
/*
@@ -1108,8 +1105,10 @@ contain_outer_selfref(Node *node)
}
static bool
-contain_outer_selfref_walker(Node *node, Index *depth)
+contain_outer_selfref_walker(Node *node, void *ctx)
{
+ Index *depth = ctx;
+
if (node == NULL)
return false;
if (IsA(node, RangeTblEntry))
@@ -1135,14 +1134,13 @@ contain_outer_selfref_walker(Node *node, Index *depth)
(*depth)++;
result = query_tree_walker(query, contain_outer_selfref_walker,
- (void *) depth, QTW_EXAMINE_RTES_BEFORE);
+ ctx, QTW_EXAMINE_RTES_BEFORE);
(*depth)--;
return result;
}
- return expression_tree_walker(node, contain_outer_selfref_walker,
- (void *) depth);
+ return expression_tree_walker(node, contain_outer_selfref_walker, ctx);
}
/*
@@ -1162,8 +1160,10 @@ inline_cte(PlannerInfo *root, CommonTableExpr *cte)
}
static bool
-inline_cte_walker(Node *node, inline_cte_walker_context *context)
+inline_cte_walker(Node *node, void *ctx)
{
+ inline_cte_walker_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Query))
@@ -1226,7 +1226,7 @@ inline_cte_walker(Node *node, inline_cte_walker_context *context)
return false;
}
- return expression_tree_walker(node, inline_cte_walker, context);
+ return expression_tree_walker(node, inline_cte_walker, ctx);
}
@@ -1871,8 +1871,10 @@ SS_replace_correlation_vars(PlannerInfo *root, Node *expr)
}
static Node *
-replace_correlation_vars_mutator(Node *node, PlannerInfo *root)
+replace_correlation_vars_mutator(Node *node, void *ctx)
{
+ PlannerInfo *root = ctx;
+
if (node == NULL)
return NULL;
if (IsA(node, Var))
@@ -1896,9 +1898,7 @@ replace_correlation_vars_mutator(Node *node, PlannerInfo *root)
if (((GroupingFunc *) node)->agglevelsup > 0)
return (Node *) replace_outer_grouping(root, (GroupingFunc *) node);
}
- return expression_tree_mutator(node,
- replace_correlation_vars_mutator,
- (void *) root);
+ return expression_tree_mutator(node, replace_correlation_vars_mutator, ctx);
}
/*
@@ -1919,8 +1919,9 @@ SS_process_sublinks(PlannerInfo *root, Node *expr, bool isQual)
}
static Node *
-process_sublinks_mutator(Node *node, process_sublinks_context *context)
+process_sublinks_mutator(Node *node, void *ctx)
{
+ process_sublinks_context *context = ctx;
process_sublinks_context locContext;
locContext.root = context->root;
@@ -2837,8 +2838,10 @@ finalize_plan(PlannerInfo *root, Plan *plan,
* expression tree to the result set.
*/
static bool
-finalize_primnode(Node *node, finalize_primnode_context *context)
+finalize_primnode(Node *node, void *ctx)
{
+ finalize_primnode_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Param))
@@ -2892,8 +2895,7 @@ finalize_primnode(Node *node, finalize_primnode_context *context)
return false; /* no more to do here */
}
- return expression_tree_walker(node, finalize_primnode,
- (void *) context);
+ return expression_tree_walker(node, finalize_primnode, ctx);
}
/*
@@ -2902,8 +2904,10 @@ finalize_primnode(Node *node, finalize_primnode_context *context)
* arguments to the result set.
*/
static bool
-finalize_agg_primnode(Node *node, finalize_primnode_context *context)
+finalize_agg_primnode(Node *node, void *ctx)
{
+ finalize_primnode_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Aggref))
@@ -2915,8 +2919,7 @@ finalize_agg_primnode(Node *node, finalize_primnode_context *context)
finalize_primnode((Node *) agg->aggfilter, context);
return false; /* there can't be any Aggrefs below here */
}
- return expression_tree_walker(node, finalize_agg_primnode,
- (void *) context);
+ return expression_tree_walker(node, finalize_agg_primnode, ctx);
}
/*
diff --git a/src/backend/optimizer/prep/prepagg.c b/src/backend/optimizer/prep/prepagg.c
index da89b55402..d3fa4897a7 100644
--- a/src/backend/optimizer/prep/prepagg.c
+++ b/src/backend/optimizer/prep/prepagg.c
@@ -52,7 +52,7 @@
#include "utils/memutils.h"
#include "utils/syscache.h"
-static bool preprocess_aggrefs_walker(Node *node, PlannerInfo *root);
+static bool preprocess_aggrefs_walker(Node *node, void *ctx);
static int find_compatible_agg(PlannerInfo *root, Aggref *newagg,
List **same_input_transnos);
static int find_compatible_trans(PlannerInfo *root, Aggref *newagg,
@@ -322,8 +322,10 @@ preprocess_aggref(Aggref *aggref, PlannerInfo *root)
}
static bool
-preprocess_aggrefs_walker(Node *node, PlannerInfo *root)
+preprocess_aggrefs_walker(Node *node, void *ctx)
{
+ PlannerInfo *root = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Aggref))
@@ -340,8 +342,7 @@ preprocess_aggrefs_walker(Node *node, PlannerInfo *root)
return false;
}
Assert(!IsA(node, SubLink));
- return expression_tree_walker(node, preprocess_aggrefs_walker,
- (void *) root);
+ return expression_tree_walker(node, preprocess_aggrefs_walker, ctx);
}
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index 41c7066d90..f6eb7eef25 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -3399,9 +3399,10 @@ typedef struct
} find_dependent_phvs_context;
static bool
-find_dependent_phvs_walker(Node *node,
- find_dependent_phvs_context *context)
+find_dependent_phvs_walker(Node *node, void *ctx)
{
+ find_dependent_phvs_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, PlaceHolderVar))
@@ -3421,7 +3422,7 @@ find_dependent_phvs_walker(Node *node,
context->sublevels_up++;
result = query_tree_walker((Query *) node,
find_dependent_phvs_walker,
- (void *) context, 0);
+ ctx, 0);
context->sublevels_up--;
return result;
}
@@ -3431,8 +3432,7 @@ find_dependent_phvs_walker(Node *node,
Assert(!IsA(node, PlaceHolderInfo));
Assert(!IsA(node, MinMaxAggInfo));
- return expression_tree_walker(node, find_dependent_phvs_walker,
- (void *) context);
+ return expression_tree_walker(node, find_dependent_phvs_walker, ctx);
}
static bool
@@ -3518,9 +3518,10 @@ typedef struct
} substitute_phv_relids_context;
static bool
-substitute_phv_relids_walker(Node *node,
- substitute_phv_relids_context *context)
+substitute_phv_relids_walker(Node *node, void *ctx)
{
+ substitute_phv_relids_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, PlaceHolderVar))
@@ -3547,7 +3548,7 @@ substitute_phv_relids_walker(Node *node,
context->sublevels_up++;
result = query_tree_walker((Query *) node,
substitute_phv_relids_walker,
- (void *) context, 0);
+ ctx, 0);
context->sublevels_up--;
return result;
}
@@ -3557,8 +3558,7 @@ substitute_phv_relids_walker(Node *node,
Assert(!IsA(node, PlaceHolderInfo));
Assert(!IsA(node, MinMaxAggInfo));
- return expression_tree_walker(node, substitute_phv_relids_walker,
- (void *) context);
+ return expression_tree_walker(node, substitute_phv_relids_walker, ctx);
}
static void
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
index 62cccf9d87..923aafd1f2 100644
--- a/src/backend/optimizer/util/appendinfo.c
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -38,8 +38,7 @@ static void make_inh_translation_list(Relation oldrelation,
Relation newrelation,
Index newvarno,
AppendRelInfo *appinfo);
-static Node *adjust_appendrel_attrs_mutator(Node *node,
- adjust_appendrel_attrs_context *context);
+static Node *adjust_appendrel_attrs_mutator(Node *node, void *ctx);
/*
@@ -211,9 +210,9 @@ adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
}
static Node *
-adjust_appendrel_attrs_mutator(Node *node,
- adjust_appendrel_attrs_context *context)
+adjust_appendrel_attrs_mutator(Node *node, void *ctx)
{
+ adjust_appendrel_attrs_context *context = ctx;
AppendRelInfo **appinfos = context->appinfos;
int nappinfos = context->nappinfos;
int cnt;
@@ -389,7 +388,7 @@ adjust_appendrel_attrs_mutator(Node *node,
phv = (PlaceHolderVar *) expression_tree_mutator(node,
adjust_appendrel_attrs_mutator,
- (void *) context);
+ ctx);
/* now fix PlaceHolderVar's relid sets */
if (phv->phlevelsup == 0)
phv->phrels = adjust_child_relids(phv->phrels, context->nappinfos,
@@ -417,11 +416,11 @@ adjust_appendrel_attrs_mutator(Node *node,
/* Recursively fix the clause itself */
newinfo->clause = (Expr *)
- adjust_appendrel_attrs_mutator((Node *) oldinfo->clause, context);
+ adjust_appendrel_attrs_mutator((Node *) oldinfo->clause, ctx);
/* and the modified version, if an OR clause */
newinfo->orclause = (Expr *)
- adjust_appendrel_attrs_mutator((Node *) oldinfo->orclause, context);
+ adjust_appendrel_attrs_mutator((Node *) oldinfo->orclause, ctx);
/* adjust relid sets too */
newinfo->clause_relids = adjust_child_relids(oldinfo->clause_relids,
@@ -473,8 +472,7 @@ adjust_appendrel_attrs_mutator(Node *node,
Assert(!IsA(node, RangeTblRef));
Assert(!IsA(node, JoinExpr));
- return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
- (void *) context);
+ return expression_tree_mutator(node, adjust_appendrel_attrs_mutator, ctx);
}
/*
diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c
index bf3a7cae60..91867e4e01 100644
--- a/src/backend/optimizer/util/clauses.c
+++ b/src/backend/optimizer/util/clauses.c
@@ -92,24 +92,22 @@ typedef struct
} max_parallel_hazard_context;
static bool contain_agg_clause_walker(Node *node, void *context);
-static bool find_window_functions_walker(Node *node, WindowFuncLists *lists);
+static bool find_window_functions_walker(Node *node, void *ctx);
static bool contain_subplans_walker(Node *node, void *context);
static bool contain_mutable_functions_walker(Node *node, void *context);
static bool contain_volatile_functions_walker(Node *node, void *context);
static bool contain_volatile_functions_not_nextval_walker(Node *node, void *context);
-static bool max_parallel_hazard_walker(Node *node,
- max_parallel_hazard_context *context);
+static bool max_parallel_hazard_walker(Node *node, void *ctx);
static bool contain_nonstrict_functions_walker(Node *node, void *context);
-static bool contain_exec_param_walker(Node *node, List *param_ids);
+static bool contain_exec_param_walker(Node *node, void *ctx);
static bool contain_context_dependent_node(Node *clause);
-static bool contain_context_dependent_node_walker(Node *node, int *flags);
+static bool contain_context_dependent_node_walker(Node *node, void *ctx);
static bool contain_leaked_vars_walker(Node *node, void *context);
static Relids find_nonnullable_rels_walker(Node *node, bool top_level);
static List *find_nonnullable_vars_walker(Node *node, bool top_level);
static bool is_strict_saop(ScalarArrayOpExpr *expr, bool falseOK);
static bool convert_saop_to_hashed_saop_walker(Node *node, void *context);
-static Node *eval_const_expressions_mutator(Node *node,
- eval_const_expressions_context *context);
+static Node *eval_const_expressions_mutator(Node *node, void *ctx);
static bool contain_non_const_walker(Node *node, void *context);
static bool ece_function_is_safe(Oid funcid,
eval_const_expressions_context *context);
@@ -145,14 +143,12 @@ static Expr *inline_function(Oid funcid, Oid result_type, Oid result_collid,
eval_const_expressions_context *context);
static Node *substitute_actual_parameters(Node *expr, int nargs, List *args,
int *usecounts);
-static Node *substitute_actual_parameters_mutator(Node *node,
- substitute_actual_parameters_context *context);
+static Node *substitute_actual_parameters_mutator(Node *node, void *ctx);
static void sql_inline_error_callback(void *arg);
static Query *substitute_actual_srf_parameters(Query *expr,
int nargs, List *args);
-static Node *substitute_actual_srf_parameters_mutator(Node *node,
- substitute_actual_srf_parameters_context *context);
-static bool pull_paramids_walker(Node *node, Bitmapset **context);
+static Node *substitute_actual_srf_parameters_mutator(Node *node, void *ctx);
+static bool pull_paramids_walker(Node *node, void *ctx);
/*****************************************************************************
@@ -235,8 +231,10 @@ find_window_functions(Node *clause, Index maxWinRef)
}
static bool
-find_window_functions_walker(Node *node, WindowFuncLists *lists)
+find_window_functions_walker(Node *node, void *ctx)
{
+ WindowFuncLists *lists = ctx;
+
if (node == NULL)
return false;
if (IsA(node, WindowFunc))
@@ -264,8 +262,7 @@ find_window_functions_walker(Node *node, WindowFuncLists *lists)
return false;
}
Assert(!IsA(node, SubLink));
- return expression_tree_walker(node, find_window_functions_walker,
- (void *) lists);
+ return expression_tree_walker(node, find_window_functions_walker, ctx);
}
@@ -713,8 +710,10 @@ max_parallel_hazard_checker(Oid func_id, void *context)
}
static bool
-max_parallel_hazard_walker(Node *node, max_parallel_hazard_context *context)
+max_parallel_hazard_walker(Node *node, void *ctx)
{
+ max_parallel_hazard_context *context = ctx;
+
if (node == NULL)
return false;
@@ -850,13 +849,11 @@ max_parallel_hazard_walker(Node *node, max_parallel_hazard_context *context)
/* Recurse into subselects */
return query_tree_walker(query,
max_parallel_hazard_walker,
- context, 0);
+ ctx, 0);
}
/* Recurse to check arguments */
- return expression_tree_walker(node,
- max_parallel_hazard_walker,
- context);
+ return expression_tree_walker(node, max_parallel_hazard_walker, ctx);
}
@@ -1027,8 +1024,10 @@ contain_exec_param(Node *clause, List *param_ids)
}
static bool
-contain_exec_param_walker(Node *node, List *param_ids)
+contain_exec_param_walker(Node *node, void *ctx)
{
+ List *param_ids = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Param))
@@ -1073,8 +1072,10 @@ contain_context_dependent_node(Node *clause)
#define CCDN_CASETESTEXPR_OK 0x0001 /* CaseTestExpr okay here? */
static bool
-contain_context_dependent_node_walker(Node *node, int *flags)
+contain_context_dependent_node_walker(Node *node, void *ctx)
{
+ int *flags = ctx;
+
if (node == NULL)
return false;
if (IsA(node, CaseTestExpr))
@@ -1104,7 +1105,7 @@ contain_context_dependent_node_walker(Node *node, int *flags)
*flags |= CCDN_CASETESTEXPR_OK;
res = expression_tree_walker(node,
contain_context_dependent_node_walker,
- (void *) flags);
+ ctx);
*flags = save_flags;
return res;
}
@@ -1128,7 +1129,7 @@ contain_context_dependent_node_walker(Node *node, int *flags)
return res;
}
return expression_tree_walker(node, contain_context_dependent_node_walker,
- (void *) flags);
+ ctx);
}
/*****************************************************************************
@@ -2278,9 +2279,10 @@ estimate_expression_value(PlannerInfo *root, Node *node)
* Recursive guts of eval_const_expressions/estimate_expression_value
*/
static Node *
-eval_const_expressions_mutator(Node *node,
- eval_const_expressions_context *context)
+eval_const_expressions_mutator(Node *node, void *ctx)
{
+ eval_const_expressions_context *context = ctx;
+
if (node == NULL)
return NULL;
switch (nodeTag(node))
@@ -4731,9 +4733,10 @@ substitute_actual_parameters(Node *expr, int nargs, List *args,
}
static Node *
-substitute_actual_parameters_mutator(Node *node,
- substitute_actual_parameters_context *context)
+substitute_actual_parameters_mutator(Node *node, void *ctx)
{
+ substitute_actual_parameters_context *context = ctx;
+
if (node == NULL)
return NULL;
if (IsA(node, Param))
@@ -4753,7 +4756,7 @@ substitute_actual_parameters_mutator(Node *node,
return list_nth(context->args, param->paramid - 1);
}
return expression_tree_mutator(node, substitute_actual_parameters_mutator,
- (void *) context);
+ ctx);
}
/*
@@ -5177,9 +5180,9 @@ substitute_actual_srf_parameters(Query *expr, int nargs, List *args)
}
static Node *
-substitute_actual_srf_parameters_mutator(Node *node,
- substitute_actual_srf_parameters_context *context)
+substitute_actual_srf_parameters_mutator(Node *node, void *ctx)
{
+ substitute_actual_srf_parameters_context *context = ctx;
Node *result;
if (node == NULL)
@@ -5189,7 +5192,7 @@ substitute_actual_srf_parameters_mutator(Node *node,
context->sublevels_up++;
result = (Node *) query_tree_mutator((Query *) node,
substitute_actual_srf_parameters_mutator,
- (void *) context,
+ ctx,
0);
context->sublevels_up--;
return result;
@@ -5214,7 +5217,7 @@ substitute_actual_srf_parameters_mutator(Node *node,
}
return expression_tree_mutator(node,
substitute_actual_srf_parameters_mutator,
- (void *) context);
+ ctx);
}
/*
@@ -5232,8 +5235,10 @@ pull_paramids(Expr *expr)
}
static bool
-pull_paramids_walker(Node *node, Bitmapset **context)
+pull_paramids_walker(Node *node, void *ctx)
{
+ Bitmapset **context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Param))
@@ -5243,6 +5248,5 @@ pull_paramids_walker(Node *node, Bitmapset **context)
*context = bms_add_member(*context, param->paramid);
return false;
}
- return expression_tree_walker(node, pull_paramids_walker,
- (void *) context);
+ return expression_tree_walker(node, pull_paramids_walker, ctx);
}
diff --git a/src/backend/optimizer/util/tlist.c b/src/backend/optimizer/util/tlist.c
index 784a1af82d..6feb248f56 100644
--- a/src/backend/optimizer/util/tlist.c
+++ b/src/backend/optimizer/util/tlist.c
@@ -59,8 +59,7 @@ typedef struct
Index current_sgref; /* current subexpr's sortgroupref, or 0 */
} split_pathtarget_context;
-static bool split_pathtarget_walker(Node *node,
- split_pathtarget_context *context);
+static bool split_pathtarget_walker(Node *node, void *ctx);
static void add_sp_item_to_pathtarget(PathTarget *target,
split_pathtarget_item *item);
static void add_sp_items_to_pathtarget(PathTarget *target, List *items);
@@ -1074,8 +1073,10 @@ split_pathtarget_at_srfs(PlannerInfo *root,
* lists. Duplicates will be gotten rid of later.
*/
static bool
-split_pathtarget_walker(Node *node, split_pathtarget_context *context)
+split_pathtarget_walker(Node *node, void *ctx)
{
+ split_pathtarget_context *context = ctx;
+
if (node == NULL)
return false;
@@ -1181,8 +1182,7 @@ split_pathtarget_walker(Node *node, split_pathtarget_context *context)
* examine its inputs.
*/
context->current_sgref = 0; /* subexpressions are not sortgroup items */
- return expression_tree_walker(node, split_pathtarget_walker,
- (void *) context);
+ return expression_tree_walker(node, split_pathtarget_walker, ctx);
}
/*
diff --git a/src/backend/optimizer/util/var.c b/src/backend/optimizer/util/var.c
index 7db86c39ef..e528e754fe 100644
--- a/src/backend/optimizer/util/var.c
+++ b/src/backend/optimizer/util/var.c
@@ -68,18 +68,14 @@ typedef struct
bool inserted_sublink; /* have we inserted a SubLink? */
} flatten_join_alias_vars_context;
-static bool pull_varnos_walker(Node *node,
- pull_varnos_context *context);
-static bool pull_varattnos_walker(Node *node, pull_varattnos_context *context);
-static bool pull_vars_walker(Node *node, pull_vars_context *context);
+static bool pull_varnos_walker(Node *node, void *ctx);
+static bool pull_varattnos_walker(Node *node, void *ctx);
+static bool pull_vars_walker(Node *node, void *ctx);
static bool contain_var_clause_walker(Node *node, void *context);
-static bool contain_vars_of_level_walker(Node *node, int *sublevels_up);
-static bool locate_var_of_level_walker(Node *node,
- locate_var_of_level_context *context);
-static bool pull_var_clause_walker(Node *node,
- pull_var_clause_context *context);
-static Node *flatten_join_alias_vars_mutator(Node *node,
- flatten_join_alias_vars_context *context);
+static bool contain_vars_of_level_walker(Node *node, void *ctx);
+static bool locate_var_of_level_walker(Node *node, void *ctx);
+static bool pull_var_clause_walker(Node *node, void *ctx);
+static Node *flatten_join_alias_vars_mutator(Node *node, void *ctx);
static Relids alias_relid_set(Query *query, Relids relids);
@@ -144,8 +140,10 @@ pull_varnos_of_level(PlannerInfo *root, Node *node, int levelsup)
}
static bool
-pull_varnos_walker(Node *node, pull_varnos_context *context)
+pull_varnos_walker(Node *node, void *ctx)
{
+ pull_varnos_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Var))
@@ -254,12 +252,11 @@ pull_varnos_walker(Node *node, pull_varnos_context *context)
context->sublevels_up++;
result = query_tree_walker((Query *) node, pull_varnos_walker,
- (void *) context, 0);
+ ctx, 0);
context->sublevels_up--;
return result;
}
- return expression_tree_walker(node, pull_varnos_walker,
- (void *) context);
+ return expression_tree_walker(node, pull_varnos_walker, ctx);
}
@@ -291,8 +288,10 @@ pull_varattnos(Node *node, Index varno, Bitmapset **varattnos)
}
static bool
-pull_varattnos_walker(Node *node, pull_varattnos_context *context)
+pull_varattnos_walker(Node *node, void *ctx)
{
+ pull_varattnos_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Var))
@@ -309,8 +308,7 @@ pull_varattnos_walker(Node *node, pull_varattnos_context *context)
/* Should not find an unplanned subquery */
Assert(!IsA(node, Query));
- return expression_tree_walker(node, pull_varattnos_walker,
- (void *) context);
+ return expression_tree_walker(node, pull_varattnos_walker, ctx);
}
@@ -342,8 +340,10 @@ pull_vars_of_level(Node *node, int levelsup)
}
static bool
-pull_vars_walker(Node *node, pull_vars_context *context)
+pull_vars_walker(Node *node, void *ctx)
{
+ pull_vars_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Var))
@@ -370,12 +370,11 @@ pull_vars_walker(Node *node, pull_vars_context *context)
context->sublevels_up++;
result = query_tree_walker((Query *) node, pull_vars_walker,
- (void *) context, 0);
+ ctx, 0);
context->sublevels_up--;
return result;
}
- return expression_tree_walker(node, pull_vars_walker,
- (void *) context);
+ return expression_tree_walker(node, pull_vars_walker, ctx);
}
@@ -439,8 +438,10 @@ contain_vars_of_level(Node *node, int levelsup)
}
static bool
-contain_vars_of_level_walker(Node *node, int *sublevels_up)
+contain_vars_of_level_walker(Node *node, void *ctx)
{
+ int *sublevels_up = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Var))
@@ -469,14 +470,12 @@ contain_vars_of_level_walker(Node *node, int *sublevels_up)
(*sublevels_up)++;
result = query_tree_walker((Query *) node,
contain_vars_of_level_walker,
- (void *) sublevels_up,
+ ctx,
0);
(*sublevels_up)--;
return result;
}
- return expression_tree_walker(node,
- contain_vars_of_level_walker,
- (void *) sublevels_up);
+ return expression_tree_walker(node, contain_vars_of_level_walker, ctx);
}
@@ -512,9 +511,10 @@ locate_var_of_level(Node *node, int levelsup)
}
static bool
-locate_var_of_level_walker(Node *node,
- locate_var_of_level_context *context)
+locate_var_of_level_walker(Node *node, void *ctx)
{
+ locate_var_of_level_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Var))
@@ -543,14 +543,12 @@ locate_var_of_level_walker(Node *node,
context->sublevels_up++;
result = query_tree_walker((Query *) node,
locate_var_of_level_walker,
- (void *) context,
+ ctx,
0);
context->sublevels_up--;
return result;
}
- return expression_tree_walker(node,
- locate_var_of_level_walker,
- (void *) context);
+ return expression_tree_walker(node, locate_var_of_level_walker, ctx);
}
@@ -614,8 +612,10 @@ pull_var_clause(Node *node, int flags)
}
static bool
-pull_var_clause_walker(Node *node, pull_var_clause_context *context)
+pull_var_clause_walker(Node *node, void *ctx)
{
+ pull_var_clause_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Var))
@@ -692,8 +692,7 @@ pull_var_clause_walker(Node *node, pull_var_clause_context *context)
else
elog(ERROR, "PlaceHolderVar found where not expected");
}
- return expression_tree_walker(node, pull_var_clause_walker,
- (void *) context);
+ return expression_tree_walker(node, pull_var_clause_walker, ctx);
}
@@ -738,9 +737,10 @@ flatten_join_alias_vars(Query *query, Node *node)
}
static Node *
-flatten_join_alias_vars_mutator(Node *node,
- flatten_join_alias_vars_context *context)
+flatten_join_alias_vars_mutator(Node *node, void *ctx)
{
+ flatten_join_alias_vars_context *context = ctx;
+
if (node == NULL)
return NULL;
if (IsA(node, Var))
@@ -868,8 +868,7 @@ flatten_join_alias_vars_mutator(Node *node,
Assert(!IsA(node, PlaceHolderInfo));
Assert(!IsA(node, MinMaxAggInfo));
- return expression_tree_mutator(node, flatten_join_alias_vars_mutator,
- (void *) context);
+ return expression_tree_mutator(node, flatten_join_alias_vars_mutator, ctx);
}
/*
diff --git a/src/backend/parser/parse_agg.c b/src/backend/parser/parse_agg.c
index 3ef9e8ee5e..1a40a5d7f2 100644
--- a/src/backend/parser/parse_agg.c
+++ b/src/backend/parser/parse_agg.c
@@ -55,19 +55,16 @@ static int check_agg_arguments(ParseState *pstate,
List *directargs,
List *args,
Expr *filter);
-static bool check_agg_arguments_walker(Node *node,
- check_agg_arguments_context *context);
+static bool check_agg_arguments_walker(Node *node, void *ctx);
static void check_ungrouped_columns(Node *node, ParseState *pstate, Query *qry,
List *groupClauses, List *groupClauseCommonVars,
bool have_non_var_grouping,
List **func_grouped_rels);
-static bool check_ungrouped_columns_walker(Node *node,
- check_ungrouped_columns_context *context);
+static bool check_ungrouped_columns_walker(Node *node, void *ctx);
static void finalize_grouping_exprs(Node *node, ParseState *pstate, Query *qry,
List *groupClauses, bool hasJoinRTEs,
bool have_non_var_grouping);
-static bool finalize_grouping_exprs_walker(Node *node,
- check_ungrouped_columns_context *context);
+static bool finalize_grouping_exprs_walker(Node *node, void *ctx);
static void check_agglevels_and_constraints(ParseState *pstate, Node *expr);
static List *expand_groupingset_node(GroupingSet *gs);
static Node *make_agg_arg(Oid argtype, Oid argcollation);
@@ -702,9 +699,10 @@ check_agg_arguments(ParseState *pstate,
}
static bool
-check_agg_arguments_walker(Node *node,
- check_agg_arguments_context *context)
+check_agg_arguments_walker(Node *node, void *ctx)
{
+ check_agg_arguments_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Var))
@@ -783,15 +781,13 @@ check_agg_arguments_walker(Node *node,
context->sublevels_up++;
result = query_tree_walker((Query *) node,
check_agg_arguments_walker,
- (void *) context,
+ ctx,
0);
context->sublevels_up--;
return result;
}
- return expression_tree_walker(node,
- check_agg_arguments_walker,
- (void *) context);
+ return expression_tree_walker(node, check_agg_arguments_walker, ctx);
}
/*
@@ -1276,9 +1272,9 @@ check_ungrouped_columns(Node *node, ParseState *pstate, Query *qry,
}
static bool
-check_ungrouped_columns_walker(Node *node,
- check_ungrouped_columns_context *context)
+check_ungrouped_columns_walker(Node *node, void *ctx)
{
+ check_ungrouped_columns_context *context = ctx;
ListCell *gl;
if (node == NULL)
@@ -1443,13 +1439,13 @@ check_ungrouped_columns_walker(Node *node,
context->sublevels_up++;
result = query_tree_walker((Query *) node,
check_ungrouped_columns_walker,
- (void *) context,
+ ctx,
0);
context->sublevels_up--;
return result;
}
- return expression_tree_walker(node, check_ungrouped_columns_walker,
- (void *) context);
+
+ return expression_tree_walker(node, check_ungrouped_columns_walker, ctx);
}
/*
@@ -1483,9 +1479,9 @@ finalize_grouping_exprs(Node *node, ParseState *pstate, Query *qry,
}
static bool
-finalize_grouping_exprs_walker(Node *node,
- check_ungrouped_columns_context *context)
+finalize_grouping_exprs_walker(Node *node, void *ctx)
{
+ check_ungrouped_columns_context *context = ctx;
ListCell *gl;
if (node == NULL)
@@ -1616,13 +1612,13 @@ finalize_grouping_exprs_walker(Node *node,
context->sublevels_up++;
result = query_tree_walker((Query *) node,
finalize_grouping_exprs_walker,
- (void *) context,
+ ctx,
0);
context->sublevels_up--;
return result;
}
- return expression_tree_walker(node, finalize_grouping_exprs_walker,
- (void *) context);
+
+ return expression_tree_walker(node, finalize_grouping_exprs_walker, ctx);
}
diff --git a/src/backend/parser/parse_collate.c b/src/backend/parser/parse_collate.c
index 7582faabb3..921caa9de6 100644
--- a/src/backend/parser/parse_collate.c
+++ b/src/backend/parser/parse_collate.c
@@ -72,9 +72,8 @@ typedef struct
int location2; /* location of expr that set collation2 */
} assign_collations_context;
-static bool assign_query_collations_walker(Node *node, ParseState *pstate);
-static bool assign_collations_walker(Node *node,
- assign_collations_context *context);
+static bool assign_query_collations_walker(Node *node, void *ctx);
+static bool assign_collations_walker(Node *node, void *ctx);
static void merge_collation_state(Oid collation,
CollateStrength strength,
int location,
@@ -123,8 +122,10 @@ assign_query_collations(ParseState *pstate, Query *query)
* have different collations.
*/
static bool
-assign_query_collations_walker(Node *node, ParseState *pstate)
+assign_query_collations_walker(Node *node, void *ctx)
{
+ ParseState *pstate = ctx;
+
/* Need do nothing for empty subexpressions */
if (node == NULL)
return false;
@@ -252,8 +253,9 @@ select_common_collation(ParseState *pstate, List *exprs, bool none_ok)
* error if there are conflicting explicit collations for different members.
*/
static bool
-assign_collations_walker(Node *node, assign_collations_context *context)
+assign_collations_walker(Node *node, void *ctx)
{
+ assign_collations_context *context = ctx;
assign_collations_context loccontext;
Oid collation;
CollateStrength strength;
diff --git a/src/backend/parser/parse_cte.c b/src/backend/parser/parse_cte.c
index 8fc8658608..5f43ccef1b 100644
--- a/src/backend/parser/parse_cte.c
+++ b/src/backend/parser/parse_cte.c
@@ -87,12 +87,12 @@ static void analyzeCTE(ParseState *pstate, CommonTableExpr *cte);
/* Dependency processing functions */
static void makeDependencyGraph(CteState *cstate);
-static bool makeDependencyGraphWalker(Node *node, CteState *cstate);
+static bool makeDependencyGraphWalker(Node *node, void *ctx);
static void TopologicalSort(ParseState *pstate, CteItem *items, int numitems);
/* Recursion validity checker functions */
static void checkWellFormedRecursion(CteState *cstate);
-static bool checkWellFormedRecursionWalker(Node *node, CteState *cstate);
+static bool checkWellFormedRecursionWalker(Node *node, void *ctx);
static void checkWellFormedSelectStmt(SelectStmt *stmt, CteState *cstate);
@@ -648,8 +648,10 @@ makeDependencyGraph(CteState *cstate)
* CTEs in a WITH RECURSIVE list.
*/
static bool
-makeDependencyGraphWalker(Node *node, CteState *cstate)
+makeDependencyGraphWalker(Node *node, void *ctx)
{
+ CteState *cstate = ctx;
+
if (node == NULL)
return false;
if (IsA(node, RangeVar))
@@ -767,9 +769,7 @@ makeDependencyGraphWalker(Node *node, CteState *cstate)
*/
return false;
}
- return raw_expression_tree_walker(node,
- makeDependencyGraphWalker,
- (void *) cstate);
+ return raw_expression_tree_walker(node, makeDependencyGraphWalker, ctx);
}
/*
@@ -927,8 +927,9 @@ checkWellFormedRecursion(CteState *cstate)
* Tree walker function to detect invalid self-references in a recursive query.
*/
static bool
-checkWellFormedRecursionWalker(Node *node, CteState *cstate)
+checkWellFormedRecursionWalker(Node *node, void *ctx)
{
+ CteState *cstate = ctx;
RecursionContext save_context = cstate->context;
if (node == NULL)
@@ -1097,9 +1098,7 @@ checkWellFormedRecursionWalker(Node *node, CteState *cstate)
checkWellFormedRecursionWalker(sl->testexpr, cstate);
return false;
}
- return raw_expression_tree_walker(node,
- checkWellFormedRecursionWalker,
- (void *) cstate);
+ return raw_expression_tree_walker(node, checkWellFormedRecursionWalker, ctx);
}
/*
diff --git a/src/backend/parser/parse_param.c b/src/backend/parser/parse_param.c
index f668abfcb3..536357326f 100644
--- a/src/backend/parser/parse_param.c
+++ b/src/backend/parser/parse_param.c
@@ -56,7 +56,7 @@ static Node *variable_paramref_hook(ParseState *pstate, ParamRef *pref);
static Node *variable_coerce_param_hook(ParseState *pstate, Param *param,
Oid targetTypeId, int32 targetTypeMod,
int location);
-static bool check_parameter_resolution_walker(Node *node, ParseState *pstate);
+static bool check_parameter_resolution_walker(Node *node, void *ctx);
static bool query_contains_extern_params_walker(Node *node, void *context);
@@ -287,8 +287,10 @@ check_variable_parameters(ParseState *pstate, Query *query)
* and yet other instances seen later might have gotten coerced.
*/
static bool
-check_parameter_resolution_walker(Node *node, ParseState *pstate)
+check_parameter_resolution_walker(Node *node, void *ctx)
{
+ ParseState *pstate = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Param))
@@ -321,10 +323,9 @@ check_parameter_resolution_walker(Node *node, ParseState *pstate)
/* Recurse into RTE subquery or not-yet-planned sublink subquery */
return query_tree_walker((Query *) node,
check_parameter_resolution_walker,
- (void *) pstate, 0);
+ ctx, 0);
}
- return expression_tree_walker(node, check_parameter_resolution_walker,
- (void *) pstate);
+ return expression_tree_walker(node, check_parameter_resolution_walker, ctx);
}
/*
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 5ab4612367..fd5609e740 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -191,7 +191,7 @@ static PruneStepResult *get_matching_range_bounds(PartitionPruneContext *context
StrategyNumber opstrategy, Datum *values, int nvalues,
FmgrInfo *partsupfunc, Bitmapset *nullkeys);
static Bitmapset *pull_exec_paramids(Expr *expr);
-static bool pull_exec_paramids_walker(Node *node, Bitmapset **context);
+static bool pull_exec_paramids_walker(Node *node, void *ctx);
static Bitmapset *get_partkey_exec_paramids(List *steps);
static PruneStepResult *perform_pruning_base_step(PartitionPruneContext *context,
PartitionPruneStepOp *opstep);
@@ -3274,8 +3274,10 @@ pull_exec_paramids(Expr *expr)
}
static bool
-pull_exec_paramids_walker(Node *node, Bitmapset **context)
+pull_exec_paramids_walker(Node *node, void *ctx)
{
+ Bitmapset **context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Param))
@@ -3286,8 +3288,7 @@ pull_exec_paramids_walker(Node *node, Bitmapset **context)
*context = bms_add_member(*context, param->paramid);
return false;
}
- return expression_tree_walker(node, pull_exec_paramids_walker,
- (void *) context);
+ return expression_tree_walker(node, pull_exec_paramids_walker, ctx);
}
/*
diff --git a/src/backend/rewrite/rewriteDefine.c b/src/backend/rewrite/rewriteDefine.c
index 213eabfbb9..244aae8048 100644
--- a/src/backend/rewrite/rewriteDefine.c
+++ b/src/backend/rewrite/rewriteDefine.c
@@ -46,7 +46,7 @@
static void checkRuleResultList(List *targetList, TupleDesc resultDesc,
bool isSelect, bool requireColumnNameMatch);
-static bool setRuleCheckAsUser_walker(Node *node, Oid *context);
+static bool setRuleCheckAsUser_walker(Node *node, void *ctx);
static void setRuleCheckAsUser_Query(Query *qry, Oid userid);
@@ -801,8 +801,10 @@ setRuleCheckAsUser(Node *node, Oid userid)
}
static bool
-setRuleCheckAsUser_walker(Node *node, Oid *context)
+setRuleCheckAsUser_walker(Node *node, void *ctx)
{
+ Oid *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Query))
@@ -810,8 +812,7 @@ setRuleCheckAsUser_walker(Node *node, Oid *context)
setRuleCheckAsUser_Query((Query *) node, *context);
return false;
}
- return expression_tree_walker(node, setRuleCheckAsUser_walker,
- (void *) context);
+ return expression_tree_walker(node, setRuleCheckAsUser_walker, ctx);
}
static void
diff --git a/src/backend/rewrite/rewriteHandler.c b/src/backend/rewrite/rewriteHandler.c
index d02fd83c0a..3294e31141 100644
--- a/src/backend/rewrite/rewriteHandler.c
+++ b/src/backend/rewrite/rewriteHandler.c
@@ -57,8 +57,7 @@ typedef struct acquireLocksOnSubLinks_context
bool for_execute; /* AcquireRewriteLocks' forExecute param */
} acquireLocksOnSubLinks_context;
-static bool acquireLocksOnSubLinks(Node *node,
- acquireLocksOnSubLinks_context *context);
+static bool acquireLocksOnSubLinks(Node *node, void *ctx);
static Query *rewriteRuleAction(Query *parsetree,
Query *rule_action,
Node *rule_qual,
@@ -298,8 +297,10 @@ AcquireRewriteLocks(Query *parsetree,
* Walker to find sublink subqueries for AcquireRewriteLocks
*/
static bool
-acquireLocksOnSubLinks(Node *node, acquireLocksOnSubLinks_context *context)
+acquireLocksOnSubLinks(Node *node, void *ctx)
{
+ acquireLocksOnSubLinks_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, SubLink))
@@ -317,7 +318,7 @@ acquireLocksOnSubLinks(Node *node, acquireLocksOnSubLinks_context *context)
* Do NOT recurse into Query nodes, because AcquireRewriteLocks already
* processed subselects of subselects for us.
*/
- return expression_tree_walker(node, acquireLocksOnSubLinks, context);
+ return expression_tree_walker(node, acquireLocksOnSubLinks, ctx);
}
@@ -1944,8 +1945,10 @@ markQueryForLocking(Query *qry, Node *jtnode,
* the SubLink's subselect link with the possibly-rewritten subquery.
*/
static bool
-fireRIRonSubLink(Node *node, List *activeRIRs)
+fireRIRonSubLink(Node *node, void *ctx)
{
+ List *activeRIRs = ctx;
+
if (node == NULL)
return false;
if (IsA(node, SubLink))
@@ -1962,8 +1965,7 @@ fireRIRonSubLink(Node *node, List *activeRIRs)
* Do NOT recurse into Query nodes, because fireRIRrules already processed
* subselects of subselects for us.
*/
- return expression_tree_walker(node, fireRIRonSubLink,
- (void *) activeRIRs);
+ return expression_tree_walker(node, fireRIRonSubLink, ctx);
}
diff --git a/src/backend/rewrite/rewriteManip.c b/src/backend/rewrite/rewriteManip.c
index 101c39553a..2e449c4c3b 100644
--- a/src/backend/rewrite/rewriteManip.c
+++ b/src/backend/rewrite/rewriteManip.c
@@ -40,13 +40,10 @@ typedef struct
int win_location;
} locate_windowfunc_context;
-static bool contain_aggs_of_level_walker(Node *node,
- contain_aggs_of_level_context *context);
-static bool locate_agg_of_level_walker(Node *node,
- locate_agg_of_level_context *context);
+static bool contain_aggs_of_level_walker(Node *node, void *ctx);
+static bool locate_agg_of_level_walker(Node *node, void *ctx);
static bool contain_windowfuncs_walker(Node *node, void *context);
-static bool locate_windowfunc_walker(Node *node,
- locate_windowfunc_context *context);
+static bool locate_windowfunc_walker(Node *node, void *ctx);
static bool checkExprHasSubLink_walker(Node *node, void *context);
static Relids offset_relid_set(Relids relids, int offset);
static Relids adjust_relid_set(Relids relids, int oldrelid, int newrelid);
@@ -81,9 +78,10 @@ contain_aggs_of_level(Node *node, int levelsup)
}
static bool
-contain_aggs_of_level_walker(Node *node,
- contain_aggs_of_level_context *context)
+contain_aggs_of_level_walker(Node *node, void *ctx)
{
+ contain_aggs_of_level_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Aggref))
@@ -106,12 +104,11 @@ contain_aggs_of_level_walker(Node *node,
context->sublevels_up++;
result = query_tree_walker((Query *) node,
contain_aggs_of_level_walker,
- (void *) context, 0);
+ ctx, 0);
context->sublevels_up--;
return result;
}
- return expression_tree_walker(node, contain_aggs_of_level_walker,
- (void *) context);
+ return expression_tree_walker(node, contain_aggs_of_level_walker, ctx);
}
/*
@@ -148,9 +145,10 @@ locate_agg_of_level(Node *node, int levelsup)
}
static bool
-locate_agg_of_level_walker(Node *node,
- locate_agg_of_level_context *context)
+locate_agg_of_level_walker(Node *node, void *ctx)
{
+ locate_agg_of_level_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Aggref))
@@ -180,12 +178,11 @@ locate_agg_of_level_walker(Node *node,
context->sublevels_up++;
result = query_tree_walker((Query *) node,
locate_agg_of_level_walker,
- (void *) context, 0);
+ ctx, 0);
context->sublevels_up--;
return result;
}
- return expression_tree_walker(node, locate_agg_of_level_walker,
- (void *) context);
+ return expression_tree_walker(node, locate_agg_of_level_walker, ctx);
}
/*
@@ -251,8 +248,10 @@ locate_windowfunc(Node *node)
}
static bool
-locate_windowfunc_walker(Node *node, locate_windowfunc_context *context)
+locate_windowfunc_walker(Node *node, void *ctx)
{
+ locate_windowfunc_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, WindowFunc))
@@ -265,8 +264,7 @@ locate_windowfunc_walker(Node *node, locate_windowfunc_context *context)
/* else fall through to examine argument */
}
/* Mustn't recurse into subselects */
- return expression_tree_walker(node, locate_windowfunc_walker,
- (void *) context);
+ return expression_tree_walker(node, locate_windowfunc_walker, ctx);
}
/*
@@ -337,8 +335,10 @@ typedef struct
} OffsetVarNodes_context;
static bool
-OffsetVarNodes_walker(Node *node, OffsetVarNodes_context *context)
+OffsetVarNodes_walker(Node *node, void *ctx)
{
+ OffsetVarNodes_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Var))
@@ -413,12 +413,11 @@ OffsetVarNodes_walker(Node *node, OffsetVarNodes_context *context)
context->sublevels_up++;
result = query_tree_walker((Query *) node, OffsetVarNodes_walker,
- (void *) context, 0);
+ ctx, 0);
context->sublevels_up--;
return result;
}
- return expression_tree_walker(node, OffsetVarNodes_walker,
- (void *) context);
+ return expression_tree_walker(node, OffsetVarNodes_walker, ctx);
}
void
@@ -502,8 +501,10 @@ typedef struct
} ChangeVarNodes_context;
static bool
-ChangeVarNodes_walker(Node *node, ChangeVarNodes_context *context)
+ChangeVarNodes_walker(Node *node, void *ctx)
{
+ ChangeVarNodes_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Var))
@@ -598,12 +599,11 @@ ChangeVarNodes_walker(Node *node, ChangeVarNodes_context *context)
context->sublevels_up++;
result = query_tree_walker((Query *) node, ChangeVarNodes_walker,
- (void *) context, 0);
+ ctx, 0);
context->sublevels_up--;
return result;
}
- return expression_tree_walker(node, ChangeVarNodes_walker,
- (void *) context);
+ return expression_tree_walker(node, ChangeVarNodes_walker, ctx);
}
void
@@ -700,9 +700,10 @@ typedef struct
} IncrementVarSublevelsUp_context;
static bool
-IncrementVarSublevelsUp_walker(Node *node,
- IncrementVarSublevelsUp_context *context)
+IncrementVarSublevelsUp_walker(Node *node, void *ctx)
{
+ IncrementVarSublevelsUp_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Var))
@@ -763,13 +764,12 @@ IncrementVarSublevelsUp_walker(Node *node,
context->min_sublevels_up++;
result = query_tree_walker((Query *) node,
IncrementVarSublevelsUp_walker,
- (void *) context,
+ ctx,
QTW_EXAMINE_RTES_BEFORE);
context->min_sublevels_up--;
return result;
}
- return expression_tree_walker(node, IncrementVarSublevelsUp_walker,
- (void *) context);
+ return expression_tree_walker(node, IncrementVarSublevelsUp_walker, ctx);
}
void
@@ -823,9 +823,10 @@ typedef struct
} rangeTableEntry_used_context;
static bool
-rangeTableEntry_used_walker(Node *node,
- rangeTableEntry_used_context *context)
+rangeTableEntry_used_walker(Node *node, void *ctx)
{
+ rangeTableEntry_used_context *context = ctx;
+
if (node == NULL)
return false;
if (IsA(node, Var))
@@ -880,12 +881,11 @@ rangeTableEntry_used_walker(Node *node,
context->sublevels_up++;
result = query_tree_walker((Query *) node, rangeTableEntry_used_walker,
- (void *) context, 0);
+ ctx, 0);
context->sublevels_up--;
return result;
}
- return expression_tree_walker(node, rangeTableEntry_used_walker,
- (void *) context);
+ return expression_tree_walker(node, rangeTableEntry_used_walker, ctx);
}
bool
@@ -1131,9 +1131,10 @@ replace_rte_variables(Node *node, int target_varno, int sublevels_up,
}
Node *
-replace_rte_variables_mutator(Node *node,
- replace_rte_variables_context *context)
+replace_rte_variables_mutator(Node *node, void *ctx)
{
+ replace_rte_variables_context *context = ctx;
+
if (node == NULL)
return NULL;
if (IsA(node, Var))
@@ -1184,15 +1185,14 @@ replace_rte_variables_mutator(Node *node,
context->inserted_sublink = ((Query *) node)->hasSubLinks;
newnode = query_tree_mutator((Query *) node,
replace_rte_variables_mutator,
- (void *) context,
+ ctx,
0);
newnode->hasSubLinks |= context->inserted_sublink;
context->inserted_sublink = save_inserted_sublink;
context->sublevels_up--;
return (Node *) newnode;
}
- return expression_tree_mutator(node, replace_rte_variables_mutator,
- (void *) context);
+ return expression_tree_mutator(node, replace_rte_variables_mutator, ctx);
}
@@ -1230,9 +1230,10 @@ typedef struct
} map_variable_attnos_context;
static Node *
-map_variable_attnos_mutator(Node *node,
- map_variable_attnos_context *context)
+map_variable_attnos_mutator(Node *node, void *ctx)
{
+ map_variable_attnos_context *context = ctx;
+
if (node == NULL)
return NULL;
if (IsA(node, Var))
@@ -1343,13 +1344,12 @@ map_variable_attnos_mutator(Node *node,
context->sublevels_up++;
newnode = query_tree_mutator((Query *) node,
map_variable_attnos_mutator,
- (void *) context,
+ ctx,
0);
context->sublevels_up--;
return (Node *) newnode;
}
- return expression_tree_mutator(node, map_variable_attnos_mutator,
- (void *) context);
+ return expression_tree_mutator(node, map_variable_attnos_mutator, ctx);
}
Node *
diff --git a/src/backend/utils/cache/plancache.c b/src/backend/utils/cache/plancache.c
index 0d6a295674..e72bf06a3c 100644
--- a/src/backend/utils/cache/plancache.c
+++ b/src/backend/utils/cache/plancache.c
@@ -109,7 +109,7 @@ static Query *QueryListGetPrimaryStmt(List *stmts);
static void AcquireExecutorLocks(List *stmt_list, bool acquire);
static void AcquirePlannerLocks(List *stmt_list, bool acquire);
static void ScanQueryForLocks(Query *parsetree, bool acquire);
-static bool ScanQueryWalker(Node *node, bool *acquire);
+static bool ScanQueryWalker(Node *node, void *ctx);
static TupleDesc PlanCacheComputeResultDesc(List *stmt_list);
static void PlanCacheRelCallback(Datum arg, Oid relid);
static void PlanCacheObjectCallback(Datum arg, int cacheid, uint32 hashvalue);
@@ -1879,8 +1879,10 @@ ScanQueryForLocks(Query *parsetree, bool acquire)
* Walker to find sublink subqueries for ScanQueryForLocks
*/
static bool
-ScanQueryWalker(Node *node, bool *acquire)
+ScanQueryWalker(Node *node, void *ctx)
{
+ bool *acquire = ctx;
+
if (node == NULL)
return false;
if (IsA(node, SubLink))
@@ -1896,8 +1898,7 @@ ScanQueryWalker(Node *node, bool *acquire)
* Do NOT recurse into Query nodes, because ScanQueryForLocks already
* processed subselects of subselects for us.
*/
- return expression_tree_walker(node, ScanQueryWalker,
- (void *) acquire);
+ return expression_tree_walker(node, ScanQueryWalker, ctx);
}
/*
diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index 82925b4b63..6c88f4b7ed 100644
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -239,7 +239,7 @@ extern PlanState *ExecInitNode(Plan *node, EState *estate, int eflags);
extern void ExecSetExecProcNode(PlanState *node, ExecProcNodeMtd function);
extern Node *MultiExecProcNode(PlanState *node);
extern void ExecEndNode(PlanState *node);
-extern bool ExecShutdownNode(PlanState *node);
+extern bool ExecShutdownNode(PlanState *node, void *ctx);
extern void ExecSetTupleBound(int64 tuples_needed, PlanState *child_node);
diff --git a/src/include/nodes/nodeFuncs.h b/src/include/nodes/nodeFuncs.h
index 93c60bde66..d0fcf6c0a3 100644
--- a/src/include/nodes/nodeFuncs.h
+++ b/src/include/nodes/nodeFuncs.h
@@ -15,6 +15,8 @@
#include "nodes/parsenodes.h"
+struct PlanState; /* avoid including execnodes.h too */
+
/* flags bits for query_tree_walker and query_tree_mutator */
#define QTW_IGNORE_RT_SUBQUERIES 0x01 /* subqueries in rtable */
@@ -32,6 +34,14 @@
/* callback function for check_functions_in_node */
typedef bool (*check_function_callback) (Oid func_id, void *context);
+/* callback functions for tree walkers */
+typedef bool (*tree_walker_callback) (Node *node, void *context);
+typedef bool (*planstate_tree_walker_callback) (struct PlanState *planstate,
+ void *context);
+
+/* callback functions for tree mutators */
+typedef Node *(*tree_mutator_callback) (Node *node, void *context);
+
extern Oid exprType(const Node *expr);
extern int32 exprTypmod(const Node *expr);
@@ -129,34 +139,38 @@ get_notclausearg(const void *notclause)
extern bool check_functions_in_node(Node *node, check_function_callback checker,
void *context);
-extern bool expression_tree_walker(Node *node, bool (*walker) (),
+extern bool expression_tree_walker(Node *node, tree_walker_callback walker,
void *context);
-extern Node *expression_tree_mutator(Node *node, Node *(*mutator) (),
+extern Node *expression_tree_mutator(Node *node, tree_mutator_callback mutator,
void *context);
-extern bool query_tree_walker(Query *query, bool (*walker) (),
+extern bool query_tree_walker(Query *query, tree_walker_callback walker,
void *context, int flags);
-extern Query *query_tree_mutator(Query *query, Node *(*mutator) (),
+extern Query *query_tree_mutator(Query *query, tree_mutator_callback mutator,
void *context, int flags);
-extern bool range_table_walker(List *rtable, bool (*walker) (),
+extern bool range_table_walker(List *rtable, tree_walker_callback walker,
void *context, int flags);
-extern List *range_table_mutator(List *rtable, Node *(*mutator) (),
+extern List *range_table_mutator(List *rtable, tree_mutator_callback mutator,
void *context, int flags);
-extern bool range_table_entry_walker(RangeTblEntry *rte, bool (*walker) (),
+extern bool range_table_entry_walker(RangeTblEntry *rte,
+ tree_walker_callback walker,
void *context, int flags);
-extern bool query_or_expression_tree_walker(Node *node, bool (*walker) (),
+extern bool query_or_expression_tree_walker(Node *node,
+ tree_walker_callback walker,
void *context, int flags);
-extern Node *query_or_expression_tree_mutator(Node *node, Node *(*mutator) (),
+extern Node *query_or_expression_tree_mutator(Node *node,
+ tree_mutator_callback mutator,
void *context, int flags);
-extern bool raw_expression_tree_walker(Node *node, bool (*walker) (),
+extern bool raw_expression_tree_walker(Node *node,
+ tree_walker_callback walker,
void *context);
-struct PlanState;
-extern bool planstate_tree_walker(struct PlanState *planstate, bool (*walker) (),
+extern bool planstate_tree_walker(struct PlanState *planstate,
+ planstate_tree_walker_callback walker,
void *context);
#endif /* NODEFUNCS_H */
diff --git a/src/include/optimizer/planmain.h b/src/include/optimizer/planmain.h
index 1566f435b3..f62fa440f8 100644
--- a/src/include/optimizer/planmain.h
+++ b/src/include/optimizer/planmain.h
@@ -115,6 +115,6 @@ extern Plan *set_plan_references(PlannerInfo *root, Plan *plan);
extern bool trivial_subqueryscan(SubqueryScan *plan);
extern void record_plan_function_dependency(PlannerInfo *root, Oid funcid);
extern void record_plan_type_dependency(PlannerInfo *root, Oid typid);
-extern bool extract_query_dependencies_walker(Node *node, PlannerInfo *root);
+extern bool extract_query_dependencies_walker(Node *node, void *ctx);
#endif /* PLANMAIN_H */
diff --git a/src/include/rewrite/rewriteManip.h b/src/include/rewrite/rewriteManip.h
index 98b9b3a288..f57eeef801 100644
--- a/src/include/rewrite/rewriteManip.h
+++ b/src/include/rewrite/rewriteManip.h
@@ -68,8 +68,7 @@ extern Node *replace_rte_variables(Node *node,
replace_rte_variables_callback callback,
void *callback_arg,
bool *outer_hasSubLinks);
-extern Node *replace_rte_variables_mutator(Node *node,
- replace_rte_variables_context *context);
+extern Node *replace_rte_variables_mutator(Node *node, void *ctx);
extern Node *map_variable_attnos(Node *node,
int target_varno, int sublevels_up,