From 6c33204112d3790cf438d6408dc4dd01ac0d313b Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Fri, 21 Nov 2025 16:05:06 -0500 Subject: [PATCH v7 1/2] Refactor dependency recording to enable dependency collection. Add new function collectDependenciesOfExpr() that collects expression dependencies into a caller-supplied ObjectAddresses structure, without immediately recording them. This enables more flexible dependency handling patterns where callers need to examine, filter, or modify dependencies before recording them. The caller is responsible for ensuring that the results are de-duplicated before being put into pg_depend. (External callers will not need to do that explicitly, since they must go through record_object_address_dependencies() which will take care of it.) This design avoids redundant de-duplication work when collecting dependencies from multiple sources. The existing recordDependencyOnExpr() function is reimplemented using the new collection function, maintaining backward compatibility. Author: Jim Jones Reviewed-by: Tom Lane Discussion: https://postgr.es/m/19cf6ae1-04cd-422c-a760-d7e75fe6cba9@uni-muenster.de --- src/backend/catalog/dependency.c | 54 +++++++++++++++++++++++++------- src/include/catalog/dependency.h | 3 ++ 2 files changed, 46 insertions(+), 11 deletions(-) diff --git a/src/backend/catalog/dependency.c b/src/backend/catalog/dependency.c index 7dded634eb8..61bdf4a577c 100644 --- a/src/backend/catalog/dependency.c +++ b/src/backend/catalog/dependency.c @@ -1554,25 +1554,57 @@ recordDependencyOnExpr(const ObjectAddress *depender, Node *expr, List *rtable, DependencyType behavior) { - find_expr_references_context context; - - context.addrs = new_object_addresses(); + ObjectAddresses *addrs; - /* Set up interpretation for Vars at varlevelsup = 0 */ - context.rtables = list_make1(rtable); + addrs = new_object_addresses(); - /* Scan the expression tree for referenceable objects */ - find_expr_references_walker(expr, &context); + /* Collect all dependencies from the expression */ + collectDependenciesOfExpr(addrs, expr, rtable); - /* Remove any duplicates */ - eliminate_duplicate_dependencies(context.addrs); + /* Remove duplicates */ + eliminate_duplicate_dependencies(addrs); /* And record 'em */ recordMultipleDependencies(depender, - context.addrs->refs, context.addrs->numrefs, + addrs->refs, addrs->numrefs, behavior); - free_object_addresses(context.addrs); + free_object_addresses(addrs); +} + +/* + * collectDependenciesOfExpr - collect expression dependencies + * + * This function analyzes an expression or query in node-tree form to + * find all the objects it refers to (tables, columns, operators, + * functions, etc.) and adds them to the provided ObjectAddresses + * structure. Unlike recordDependencyOnExpr, this function does not + * immediately record the dependencies, allowing the caller to add to, + * filter, or modify the collected dependencies before recording them. + * + * rtable is the rangetable to be used to interpret Vars with varlevelsup=0. + * It can be NIL if no such variables are expected. + * + * Note: the returned list may well contain duplicates. The caller should + * de-duplicate before recording the dependencies. Within this file, callers + * must call eliminate_duplicate_dependencies(). External callers typically + * go through record_object_address_dependencies() which will see to that. + * This choice allows collecting dependencies from multiple sources without + * redundant de-duplication work. + */ +void +collectDependenciesOfExpr(ObjectAddresses *addrs, + Node *expr, List *rtable) +{ + find_expr_references_context context; + + context.addrs = addrs; + + /* Set up interpretation for Vars at varlevelsup = 0 */ + context.rtables = list_make1(rtable); + + /* Scan the expression tree for referenceable objects */ + find_expr_references_walker(expr, &context); } /* diff --git a/src/include/catalog/dependency.h b/src/include/catalog/dependency.h index 0ea7ccf5243..2712befc8e7 100644 --- a/src/include/catalog/dependency.h +++ b/src/include/catalog/dependency.h @@ -114,6 +114,9 @@ extern void recordDependencyOnExpr(const ObjectAddress *depender, Node *expr, List *rtable, DependencyType behavior); +extern void collectDependenciesOfExpr(ObjectAddresses *addrs, + Node *expr, List *rtable); + extern void recordDependencyOnSingleRelExpr(const ObjectAddress *depender, Node *expr, Oid relId, DependencyType behavior, -- 2.43.7