PostgreSQL Source Code git master
ruleutils.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * ruleutils.c
4 * Functions to convert stored expressions/querytrees back to
5 * source text
6 *
7 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
8 * Portions Copyright (c) 1994, Regents of the University of California
9 *
10 *
11 * IDENTIFICATION
12 * src/backend/utils/adt/ruleutils.c
13 *
14 *-------------------------------------------------------------------------
15 */
16#include "postgres.h"
17
18#include <ctype.h>
19#include <unistd.h>
20#include <fcntl.h>
21
22#include "access/amapi.h"
23#include "access/htup_details.h"
24#include "access/relation.h"
25#include "access/table.h"
26#include "catalog/pg_aggregate.h"
27#include "catalog/pg_am.h"
28#include "catalog/pg_authid.h"
29#include "catalog/pg_collation.h"
30#include "catalog/pg_constraint.h"
31#include "catalog/pg_depend.h"
32#include "catalog/pg_language.h"
33#include "catalog/pg_opclass.h"
34#include "catalog/pg_operator.h"
35#include "catalog/pg_partitioned_table.h"
36#include "catalog/pg_proc.h"
37#include "catalog/pg_statistic_ext.h"
38#include "catalog/pg_trigger.h"
39#include "catalog/pg_type.h"
40#include "commands/defrem.h"
41#include "commands/tablespace.h"
42#include "common/keywords.h"
43#include "executor/spi.h"
44#include "funcapi.h"
45#include "mb/pg_wchar.h"
46#include "miscadmin.h"
47#include "nodes/makefuncs.h"
48#include "nodes/nodeFuncs.h"
49#include "nodes/pathnodes.h"
50#include "optimizer/optimizer.h"
51#include "parser/parse_agg.h"
52#include "parser/parse_func.h"
53#include "parser/parse_oper.h"
54#include "parser/parse_relation.h"
55#include "parser/parser.h"
56#include "parser/parsetree.h"
57#include "rewrite/rewriteHandler.h"
58#include "rewrite/rewriteManip.h"
59#include "rewrite/rewriteSupport.h"
60#include "utils/array.h"
61#include "utils/builtins.h"
62#include "utils/fmgroids.h"
63#include "utils/guc.h"
64#include "utils/hsearch.h"
65#include "utils/lsyscache.h"
66#include "utils/partcache.h"
67#include "utils/rel.h"
68#include "utils/ruleutils.h"
69#include "utils/snapmgr.h"
70#include "utils/syscache.h"
71#include "utils/typcache.h"
72#include "utils/varlena.h"
73#include "utils/xml.h"
74
75/* ----------
76 * Pretty formatting constants
77 * ----------
78 */
79
80/* Indent counts */
81#define PRETTYINDENT_STD 8
82#define PRETTYINDENT_JOIN 4
83#define PRETTYINDENT_VAR 4
84
85#define PRETTYINDENT_LIMIT 40 /* wrap limit */
86
87/* Pretty flags */
88#define PRETTYFLAG_PAREN 0x0001
89#define PRETTYFLAG_INDENT 0x0002
90#define PRETTYFLAG_SCHEMA 0x0004
91
92/* Standard conversion of a "bool pretty" option to detailed flags */
93#define GET_PRETTY_FLAGS(pretty) \
94 ((pretty) ? (PRETTYFLAG_PAREN | PRETTYFLAG_INDENT | PRETTYFLAG_SCHEMA) \
95 : PRETTYFLAG_INDENT)
96
97/* Default line length for pretty-print wrapping: 0 means wrap always */
98#define WRAP_COLUMN_DEFAULT 0
99
100/* macros to test if pretty action needed */
101#define PRETTY_PAREN(context) ((context)->prettyFlags & PRETTYFLAG_PAREN)
102#define PRETTY_INDENT(context) ((context)->prettyFlags & PRETTYFLAG_INDENT)
103#define PRETTY_SCHEMA(context) ((context)->prettyFlags & PRETTYFLAG_SCHEMA)
104
105
106/* ----------
107 * Local data types
108 * ----------
109 */
110
111/* Context info needed for invoking a recursive querytree display routine */
112typedef struct
113{
114 StringInfo buf; /* output buffer to append to */
115 List *namespaces; /* List of deparse_namespace nodes */
116 TupleDesc resultDesc; /* if top level of a view, the view's tupdesc */
117 List *targetList; /* Current query level's SELECT targetlist */
118 List *windowClause; /* Current query level's WINDOW clause */
119 int prettyFlags; /* enabling of pretty-print functions */
120 int wrapColumn; /* max line length, or -1 for no limit */
121 int indentLevel; /* current indent level for pretty-print */
122 bool varprefix; /* true to print prefixes on Vars */
123 bool colNamesVisible; /* do we care about output column names? */
124 bool inGroupBy; /* deparsing GROUP BY clause? */
125 bool varInOrderBy; /* deparsing simple Var in ORDER BY? */
126 Bitmapset *appendparents; /* if not null, map child Vars of these relids
127 * back to the parent rel */
128} deparse_context;
129
130/*
131 * Each level of query context around a subtree needs a level of Var namespace.
132 * A Var having varlevelsup=N refers to the N'th item (counting from 0) in
133 * the current context's namespaces list.
134 *
135 * rtable is the list of actual RTEs from the Query or PlannedStmt.
136 * rtable_names holds the alias name to be used for each RTE (either a C
137 * string, or NULL for nameless RTEs such as unnamed joins).
138 * rtable_columns holds the column alias names to be used for each RTE.
139 *
140 * subplans is a list of Plan trees for SubPlans and CTEs (it's only used
141 * in the PlannedStmt case).
142 * ctes is a list of CommonTableExpr nodes (only used in the Query case).
143 * appendrels, if not null (it's only used in the PlannedStmt case), is an
144 * array of AppendRelInfo nodes, indexed by child relid. We use that to map
145 * child-table Vars to their inheritance parents.
146 *
147 * In some cases we need to make names of merged JOIN USING columns unique
148 * across the whole query, not only per-RTE. If so, unique_using is true
149 * and using_names is a list of C strings representing names already assigned
150 * to USING columns.
151 *
152 * When deparsing plan trees, there is always just a single item in the
153 * deparse_namespace list (since a plan tree never contains Vars with
154 * varlevelsup > 0). We store the Plan node that is the immediate
155 * parent of the expression to be deparsed, as well as a list of that
156 * Plan's ancestors. In addition, we store its outer and inner subplan nodes,
157 * as well as their targetlists, and the index tlist if the current plan node
158 * might contain INDEX_VAR Vars. (These fields could be derived on-the-fly
159 * from the current Plan node, but it seems notationally clearer to set them
160 * up as separate fields.)
161 */
162typedef struct
163{
164 List *rtable; /* List of RangeTblEntry nodes */
165 List *rtable_names; /* Parallel list of names for RTEs */
166 List *rtable_columns; /* Parallel list of deparse_columns structs */
167 List *subplans; /* List of Plan trees for SubPlans */
168 List *ctes; /* List of CommonTableExpr nodes */
169 AppendRelInfo **appendrels; /* Array of AppendRelInfo nodes, or NULL */
170 char *ret_old_alias; /* alias for OLD in RETURNING list */
171 char *ret_new_alias; /* alias for NEW in RETURNING list */
172 /* Workspace for column alias assignment: */
173 bool unique_using; /* Are we making USING names globally unique */
174 List *using_names; /* List of assigned names for USING columns */
175 /* Remaining fields are used only when deparsing a Plan tree: */
176 Plan *plan; /* immediate parent of current expression */
177 List *ancestors; /* ancestors of plan */
178 Plan *outer_plan; /* outer subnode, or NULL if none */
179 Plan *inner_plan; /* inner subnode, or NULL if none */
180 List *outer_tlist; /* referent for OUTER_VAR Vars */
181 List *inner_tlist; /* referent for INNER_VAR Vars */
182 List *index_tlist; /* referent for INDEX_VAR Vars */
183 /* Special namespace representing a function signature: */
184 char *funcname;
185 int numargs;
186 char **argnames;
187} deparse_namespace;
188
189/*
190 * Per-relation data about column alias names.
191 *
192 * Selecting aliases is unreasonably complicated because of the need to dump
193 * rules/views whose underlying tables may have had columns added, deleted, or
194 * renamed since the query was parsed. We must nonetheless print the rule/view
195 * in a form that can be reloaded and will produce the same results as before.
196 *
197 * For each RTE used in the query, we must assign column aliases that are
198 * unique within that RTE. SQL does not require this of the original query,
199 * but due to factors such as *-expansion we need to be able to uniquely
200 * reference every column in a decompiled query. As long as we qualify all
201 * column references, per-RTE uniqueness is sufficient for that.
202 *
203 * However, we can't ensure per-column name uniqueness for unnamed join RTEs,
204 * since they just inherit column names from their input RTEs, and we can't
205 * rename the columns at the join level. Most of the time this isn't an issue
206 * because we don't need to reference the join's output columns as such; we
207 * can reference the input columns instead. That approach can fail for merged
208 * JOIN USING columns, however, so when we have one of those in an unnamed
209 * join, we have to make that column's alias globally unique across the whole
210 * query to ensure it can be referenced unambiguously.
211 *
212 * Another problem is that a JOIN USING clause requires the columns to be
213 * merged to have the same aliases in both input RTEs, and that no other
214 * columns in those RTEs or their children conflict with the USING names.
215 * To handle that, we do USING-column alias assignment in a recursive
216 * traversal of the query's jointree. When descending through a JOIN with
217 * USING, we preassign the USING column names to the child columns, overriding
218 * other rules for column alias assignment. We also mark each RTE with a list
219 * of all USING column names selected for joins containing that RTE, so that
220 * when we assign other columns' aliases later, we can avoid conflicts.
221 *
222 * Another problem is that if a JOIN's input tables have had columns added or
223 * deleted since the query was parsed, we must generate a column alias list
224 * for the join that matches the current set of input columns --- otherwise, a
225 * change in the number of columns in the left input would throw off matching
226 * of aliases to columns of the right input. Thus, positions in the printable
227 * column alias list are not necessarily one-for-one with varattnos of the
228 * JOIN, so we need a separate new_colnames[] array for printing purposes.
229 *
230 * Finally, when dealing with wide tables we risk O(N^2) costs in assigning
231 * non-duplicate column names. We ameliorate that by using a hash table that
232 * holds all the strings appearing in colnames, new_colnames, and parentUsing.
233 */
234typedef struct
235{
236 /*
237 * colnames is an array containing column aliases to use for columns that
238 * existed when the query was parsed. Dropped columns have NULL entries.
239 * This array can be directly indexed by varattno to get a Var's name.
240 *
241 * Non-NULL entries are guaranteed unique within the RTE, *except* when
242 * this is for an unnamed JOIN RTE. In that case we merely copy up names
243 * from the two input RTEs.
244 *
245 * During the recursive descent in set_using_names(), forcible assignment
246 * of a child RTE's column name is represented by pre-setting that element
247 * of the child's colnames array. So at that stage, NULL entries in this
248 * array just mean that no name has been preassigned, not necessarily that
249 * the column is dropped.
250 */
251 int num_cols; /* length of colnames[] array */
252 char **colnames; /* array of C strings and NULLs */
253
254 /*
255 * new_colnames is an array containing column aliases to use for columns
256 * that would exist if the query was re-parsed against the current
257 * definitions of its base tables. This is what to print as the column
258 * alias list for the RTE. This array does not include dropped columns,
259 * but it will include columns added since original parsing. Indexes in
260 * it therefore have little to do with current varattno values. As above,
261 * entries are unique unless this is for an unnamed JOIN RTE. (In such an
262 * RTE, we never actually print this array, but we must compute it anyway
263 * for possible use in computing column names of upper joins.) The
264 * parallel array is_new_col marks which of these columns are new since
265 * original parsing. Entries with is_new_col false must match the
266 * non-NULL colnames entries one-for-one.
267 */
268 int num_new_cols; /* length of new_colnames[] array */
269 char **new_colnames; /* array of C strings */
270 bool *is_new_col; /* array of bool flags */
271
272 /* This flag tells whether we should actually print a column alias list */
273 bool printaliases;
274
275 /* This list has all names used as USING names in joins above this RTE */
276 List *parentUsing; /* names assigned to parent merged columns */
277
278 /*
279 * If this struct is for a JOIN RTE, we fill these fields during the
280 * set_using_names() pass to describe its relationship to its child RTEs.
281 *
282 * leftattnos and rightattnos are arrays with one entry per existing
283 * output column of the join (hence, indexable by join varattno). For a
284 * simple reference to a column of the left child, leftattnos[i] is the
285 * child RTE's attno and rightattnos[i] is zero; and conversely for a
286 * column of the right child. But for merged columns produced by JOIN
287 * USING/NATURAL JOIN, both leftattnos[i] and rightattnos[i] are nonzero.
288 * Note that a simple reference might be to a child RTE column that's been
289 * dropped; but that's OK since the column could not be used in the query.
290 *
291 * If it's a JOIN USING, usingNames holds the alias names selected for the
292 * merged columns (these might be different from the original USING list,
293 * if we had to modify names to achieve uniqueness).
294 */
295 int leftrti; /* rangetable index of left child */
296 int rightrti; /* rangetable index of right child */
297 int *leftattnos; /* left-child varattnos of join cols, or 0 */
298 int *rightattnos; /* right-child varattnos of join cols, or 0 */
299 List *usingNames; /* names assigned to merged columns */
300
301 /*
302 * Hash table holding copies of all the strings appearing in this struct's
303 * colnames, new_colnames, and parentUsing. We use a hash table only for
304 * sufficiently wide relations, and only during the colname-assignment
305 * functions set_relation_column_names and set_join_column_names;
306 * otherwise, names_hash is NULL.
307 */
308 HTAB *names_hash; /* entries are just strings */
309} deparse_columns;
310
311/* This macro is analogous to rt_fetch(), but for deparse_columns structs */
312#define deparse_columns_fetch(rangetable_index, dpns) \
313 ((deparse_columns *) list_nth((dpns)->rtable_columns, (rangetable_index)-1))
314
315/*
316 * Entry in set_rtable_names' hash table
317 */
318typedef struct
319{
320 char name[NAMEDATALEN]; /* Hash key --- must be first */
321 int counter; /* Largest addition used so far for name */
322} NameHashEntry;
323
324/* Callback signature for resolve_special_varno() */
325typedef void (*rsv_callback) (Node *node, deparse_context *context,
326 void *callback_arg);
327
328
329/* ----------
330 * Global data
331 * ----------
332 */
333static SPIPlanPtr plan_getrulebyoid = NULL;
334static const char *const query_getrulebyoid = "SELECT * FROM pg_catalog.pg_rewrite WHERE oid = $1";
335static SPIPlanPtr plan_getviewrule = NULL;
336static const char *const query_getviewrule = "SELECT * FROM pg_catalog.pg_rewrite WHERE ev_class = $1 AND rulename = $2";
337
338/* GUC parameters */
339bool quote_all_identifiers = false;
340
341
342/* ----------
343 * Local functions
344 *
345 * Most of these functions used to use fixed-size buffers to build their
346 * results. Now, they take an (already initialized) StringInfo object
347 * as a parameter, and append their text output to its contents.
348 * ----------
349 */
350static char *deparse_expression_pretty(Node *expr, List *dpcontext,
351 bool forceprefix, bool showimplicit,
352 int prettyFlags, int startIndent);
353static char *pg_get_viewdef_worker(Oid viewoid,
354 int prettyFlags, int wrapColumn);
355static char *pg_get_triggerdef_worker(Oid trigid, bool pretty);
356static int decompile_column_index_array(Datum column_index_array, Oid relId,
357 bool withPeriod, StringInfo buf);
358static char *pg_get_ruledef_worker(Oid ruleoid, int prettyFlags);
359static char *pg_get_indexdef_worker(Oid indexrelid, int colno,
360 const Oid *excludeOps,
361 bool attrsOnly, bool keysOnly,
362 bool showTblSpc, bool inherits,
363 int prettyFlags, bool missing_ok);
364static char *pg_get_statisticsobj_worker(Oid statextid, bool columns_only,
365 bool missing_ok);
366static char *pg_get_partkeydef_worker(Oid relid, int prettyFlags,
367 bool attrsOnly, bool missing_ok);
368static char *pg_get_constraintdef_worker(Oid constraintId, bool fullCommand,
369 int prettyFlags, bool missing_ok);
370static text *pg_get_expr_worker(text *expr, Oid relid, int prettyFlags);
371static int print_function_arguments(StringInfo buf, HeapTuple proctup,
372 bool print_table_args, bool print_defaults);
373static void print_function_rettype(StringInfo buf, HeapTuple proctup);
374static void print_function_trftypes(StringInfo buf, HeapTuple proctup);
375static void print_function_sqlbody(StringInfo buf, HeapTuple proctup);
376static void set_rtable_names(deparse_namespace *dpns, List *parent_namespaces,
377 Bitmapset *rels_used);
378static void set_deparse_for_query(deparse_namespace *dpns, Query *query,
379 List *parent_namespaces);
380static void set_simple_column_names(deparse_namespace *dpns);
381static bool has_dangerous_join_using(deparse_namespace *dpns, Node *jtnode);
382static void set_using_names(deparse_namespace *dpns, Node *jtnode,
383 List *parentUsing);
384static void set_relation_column_names(deparse_namespace *dpns,
385 RangeTblEntry *rte,
386 deparse_columns *colinfo);
387static void set_join_column_names(deparse_namespace *dpns, RangeTblEntry *rte,
388 deparse_columns *colinfo);
389static bool colname_is_unique(const char *colname, deparse_namespace *dpns,
390 deparse_columns *colinfo);
391static char *make_colname_unique(char *colname, deparse_namespace *dpns,
392 deparse_columns *colinfo);
393static void expand_colnames_array_to(deparse_columns *colinfo, int n);
394static void build_colinfo_names_hash(deparse_columns *colinfo);
395static void add_to_names_hash(deparse_columns *colinfo, const char *name);
396static void destroy_colinfo_names_hash(deparse_columns *colinfo);
397static void identify_join_columns(JoinExpr *j, RangeTblEntry *jrte,
398 deparse_columns *colinfo);
399static char *get_rtable_name(int rtindex, deparse_context *context);
400static void set_deparse_plan(deparse_namespace *dpns, Plan *plan);
401static Plan *find_recursive_union(deparse_namespace *dpns,
402 WorkTableScan *wtscan);
403static void push_child_plan(deparse_namespace *dpns, Plan *plan,
404 deparse_namespace *save_dpns);
405static void pop_child_plan(deparse_namespace *dpns,
406 deparse_namespace *save_dpns);
407static void push_ancestor_plan(deparse_namespace *dpns, ListCell *ancestor_cell,
408 deparse_namespace *save_dpns);
409static void pop_ancestor_plan(deparse_namespace *dpns,
410 deparse_namespace *save_dpns);
411static void make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,
412 int prettyFlags);
413static void make_viewdef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,
414 int prettyFlags, int wrapColumn);
415static void get_query_def(Query *query, StringInfo buf, List *parentnamespace,
416 TupleDesc resultDesc, bool colNamesVisible,
417 int prettyFlags, int wrapColumn, int startIndent);
418static void get_values_def(List *values_lists, deparse_context *context);
419static void get_with_clause(Query *query, deparse_context *context);
420static void get_select_query_def(Query *query, deparse_context *context);
421static void get_insert_query_def(Query *query, deparse_context *context);
422static void get_update_query_def(Query *query, deparse_context *context);
423static void get_update_query_targetlist_def(Query *query, List *targetList,
424 deparse_context *context,
425 RangeTblEntry *rte);
426static void get_delete_query_def(Query *query, deparse_context *context);
427static void get_merge_query_def(Query *query, deparse_context *context);
428static void get_utility_query_def(Query *query, deparse_context *context);
429static void get_basic_select_query(Query *query, deparse_context *context);
430static void get_target_list(List *targetList, deparse_context *context);
431static void get_returning_clause(Query *query, deparse_context *context);
432static void get_setop_query(Node *setOp, Query *query,
433 deparse_context *context);
434static Node *get_rule_sortgroupclause(Index ref, List *tlist,
435 bool force_colno,
436 deparse_context *context);
437static void get_rule_groupingset(GroupingSet *gset, List *targetlist,
438 bool omit_parens, deparse_context *context);
439static void get_rule_orderby(List *orderList, List *targetList,
440 bool force_colno, deparse_context *context);
441static void get_rule_windowclause(Query *query, deparse_context *context);
442static void get_rule_windowspec(WindowClause *wc, List *targetList,
443 deparse_context *context);
444static void get_window_frame_options(int frameOptions,
445 Node *startOffset, Node *endOffset,
446 deparse_context *context);
447static char *get_variable(Var *var, int levelsup, bool istoplevel,
448 deparse_context *context);
449static void get_special_variable(Node *node, deparse_context *context,
450 void *callback_arg);
451static void resolve_special_varno(Node *node, deparse_context *context,
452 rsv_callback callback, void *callback_arg);
453static Node *find_param_referent(Param *param, deparse_context *context,
454 deparse_namespace **dpns_p, ListCell **ancestor_cell_p);
455static SubPlan *find_param_generator(Param *param, deparse_context *context,
456 int *column_p);
457static SubPlan *find_param_generator_initplan(Param *param, Plan *plan,
458 int *column_p);
459static void get_parameter(Param *param, deparse_context *context);
460static const char *get_simple_binary_op_name(OpExpr *expr);
461static bool isSimpleNode(Node *node, Node *parentNode, int prettyFlags);
462static void appendContextKeyword(deparse_context *context, const char *str,
463 int indentBefore, int indentAfter, int indentPlus);
464static void removeStringInfoSpaces(StringInfo str);
465static void get_rule_expr(Node *node, deparse_context *context,
466 bool showimplicit);
467static void get_rule_expr_toplevel(Node *node, deparse_context *context,
468 bool showimplicit);
469static void get_rule_list_toplevel(List *lst, deparse_context *context,
470 bool showimplicit);
471static void get_rule_expr_funccall(Node *node, deparse_context *context,
472 bool showimplicit);
473static bool looks_like_function(Node *node);
474static void get_oper_expr(OpExpr *expr, deparse_context *context);
475static void get_func_expr(FuncExpr *expr, deparse_context *context,
476 bool showimplicit);
477static void get_agg_expr(Aggref *aggref, deparse_context *context,
478 Aggref *original_aggref);
479static void get_agg_expr_helper(Aggref *aggref, deparse_context *context,
480 Aggref *original_aggref, const char *funcname,
481 const char *options, bool is_json_objectagg);
482static void get_agg_combine_expr(Node *node, deparse_context *context,
483 void *callback_arg);
484static void get_windowfunc_expr(WindowFunc *wfunc, deparse_context *context);
485static void get_windowfunc_expr_helper(WindowFunc *wfunc, deparse_context *context,
486 const char *funcname, const char *options,
487 bool is_json_objectagg);
488static bool get_func_sql_syntax(FuncExpr *expr, deparse_context *context);
489static void get_coercion_expr(Node *arg, deparse_context *context,
490 Oid resulttype, int32 resulttypmod,
491 Node *parentNode);
492static void get_const_expr(Const *constval, deparse_context *context,
493 int showtype);
494static void get_const_collation(Const *constval, deparse_context *context);
495static void get_json_format(JsonFormat *format, StringInfo buf);
496static void get_json_returning(JsonReturning *returning, StringInfo buf,
497 bool json_format_by_default);
498static void get_json_constructor(JsonConstructorExpr *ctor,
499 deparse_context *context, bool showimplicit);
500static void get_json_constructor_options(JsonConstructorExpr *ctor,
501 StringInfo buf);
502static void get_json_agg_constructor(JsonConstructorExpr *ctor,
503 deparse_context *context,
504 const char *funcname,
505 bool is_json_objectagg);
506static void simple_quote_literal(StringInfo buf, const char *val);
507static void get_sublink_expr(SubLink *sublink, deparse_context *context);
508static void get_tablefunc(TableFunc *tf, deparse_context *context,
509 bool showimplicit);
510static void get_from_clause(Query *query, const char *prefix,
511 deparse_context *context);
512static void get_from_clause_item(Node *jtnode, Query *query,
513 deparse_context *context);
514static void get_rte_alias(RangeTblEntry *rte, int varno, bool use_as,
515 deparse_context *context);
516static void get_column_alias_list(deparse_columns *colinfo,
517 deparse_context *context);
518static void get_from_clause_coldeflist(RangeTblFunction *rtfunc,
519 deparse_columns *colinfo,
520 deparse_context *context);
521static void get_tablesample_def(TableSampleClause *tablesample,
522 deparse_context *context);
523static void get_opclass_name(Oid opclass, Oid actual_datatype,
524 StringInfo buf);
525static Node *processIndirection(Node *node, deparse_context *context);
526static void printSubscripts(SubscriptingRef *sbsref, deparse_context *context);
527static char *get_relation_name(Oid relid);
528static char *generate_relation_name(Oid relid, List *namespaces);
529static char *generate_qualified_relation_name(Oid relid);
530static char *generate_function_name(Oid funcid, int nargs,
531 List *argnames, Oid *argtypes,
532 bool has_variadic, bool *use_variadic_p,
533 bool inGroupBy);
534static char *generate_operator_name(Oid operid, Oid arg1, Oid arg2);
535static void add_cast_to(StringInfo buf, Oid typid);
536static char *generate_qualified_type_name(Oid typid);
537static text *string_to_text(char *str);
538static char *flatten_reloptions(Oid relid);
539static void get_reloptions(StringInfo buf, Datum reloptions);
540static void get_json_path_spec(Node *path_spec, deparse_context *context,
541 bool showimplicit);
542static void get_json_table_columns(TableFunc *tf, JsonTablePathScan *scan,
543 deparse_context *context,
544 bool showimplicit);
545static void get_json_table_nested_columns(TableFunc *tf, JsonTablePlan *plan,
546 deparse_context *context,
547 bool showimplicit,
548 bool needcomma);
549
550#define only_marker(rte) ((rte)->inh ? "" : "ONLY ")
551
552
553/* ----------
554 * pg_get_ruledef - Do it all and return a text
555 * that could be used as a statement
556 * to recreate the rule
557 * ----------
558 */
559Datum
560pg_get_ruledef(PG_FUNCTION_ARGS)
561{
562 Oid ruleoid = PG_GETARG_OID(0);
563 int prettyFlags;
564 char *res;
565
566 prettyFlags = PRETTYFLAG_INDENT;
567
568 res = pg_get_ruledef_worker(ruleoid, prettyFlags);
569
570 if (res == NULL)
571 PG_RETURN_NULL();
572
573 PG_RETURN_TEXT_P(string_to_text(res));
574}
575
576
577Datum
578pg_get_ruledef_ext(PG_FUNCTION_ARGS)
579{
580 Oid ruleoid = PG_GETARG_OID(0);
581 bool pretty = PG_GETARG_BOOL(1);
582 int prettyFlags;
583 char *res;
584
585 prettyFlags = GET_PRETTY_FLAGS(pretty);
586
587 res = pg_get_ruledef_worker(ruleoid, prettyFlags);
588
589 if (res == NULL)
590 PG_RETURN_NULL();
591
592 PG_RETURN_TEXT_P(string_to_text(res));
593}
594
595
596static char *
597pg_get_ruledef_worker(Oid ruleoid, int prettyFlags)
598{
599 Datum args[1];
600 char nulls[1];
601 int spirc;
602 HeapTuple ruletup;
603 TupleDesc rulettc;
604 StringInfoData buf;
605
606 /*
607 * Do this first so that string is alloc'd in outer context not SPI's.
608 */
609 initStringInfo(&buf);
610
611 /*
612 * Connect to SPI manager
613 */
614 SPI_connect();
615
616 /*
617 * On the first call prepare the plan to lookup pg_rewrite. We read
618 * pg_rewrite over the SPI manager instead of using the syscache to be
619 * checked for read access on pg_rewrite.
620 */
621 if (plan_getrulebyoid == NULL)
622 {
623 Oid argtypes[1];
624 SPIPlanPtr plan;
625
626 argtypes[0] = OIDOID;
627 plan = SPI_prepare(query_getrulebyoid, 1, argtypes);
628 if (plan == NULL)
629 elog(ERROR, "SPI_prepare failed for \"%s\"", query_getrulebyoid);
630 SPI_keepplan(plan);
631 plan_getrulebyoid = plan;
632 }
633
634 /*
635 * Get the pg_rewrite tuple for this rule
636 */
637 args[0] = ObjectIdGetDatum(ruleoid);
638 nulls[0] = ' ';
639 spirc = SPI_execute_plan(plan_getrulebyoid, args, nulls, true, 0);
640 if (spirc != SPI_OK_SELECT)
641 elog(ERROR, "failed to get pg_rewrite tuple for rule %u", ruleoid);
642 if (SPI_processed != 1)
643 {
644 /*
645 * There is no tuple data available here, just keep the output buffer
646 * empty.
647 */
648 }
649 else
650 {
651 /*
652 * Get the rule's definition and put it into executor's memory
653 */
654 ruletup = SPI_tuptable->vals[0];
655 rulettc = SPI_tuptable->tupdesc;
656 make_ruledef(&buf, ruletup, rulettc, prettyFlags);
657 }
658
659 /*
660 * Disconnect from SPI manager
661 */
662 if (SPI_finish() != SPI_OK_FINISH)
663 elog(ERROR, "SPI_finish failed");
664
665 if (buf.len == 0)
666 return NULL;
667
668 return buf.data;
669}
670
671
672/* ----------
673 * pg_get_viewdef - Mainly the same thing, but we
674 * only return the SELECT part of a view
675 * ----------
676 */
677Datum
678pg_get_viewdef(PG_FUNCTION_ARGS)
679{
680 /* By OID */
681 Oid viewoid = PG_GETARG_OID(0);
682 int prettyFlags;
683 char *res;
684
685 prettyFlags = PRETTYFLAG_INDENT;
686
687 res = pg_get_viewdef_worker(viewoid, prettyFlags, WRAP_COLUMN_DEFAULT);
688
689 if (res == NULL)
690 PG_RETURN_NULL();
691
692 PG_RETURN_TEXT_P(string_to_text(res));
693}
694
695
696Datum
697pg_get_viewdef_ext(PG_FUNCTION_ARGS)
698{
699 /* By OID */
700 Oid viewoid = PG_GETARG_OID(0);
701 bool pretty = PG_GETARG_BOOL(1);
702 int prettyFlags;
703 char *res;
704
705 prettyFlags = GET_PRETTY_FLAGS(pretty);
706
707 res = pg_get_viewdef_worker(viewoid, prettyFlags, WRAP_COLUMN_DEFAULT);
708
709 if (res == NULL)
710 PG_RETURN_NULL();
711
712 PG_RETURN_TEXT_P(string_to_text(res));
713}
714
715Datum
716pg_get_viewdef_wrap(PG_FUNCTION_ARGS)
717{
718 /* By OID */
719 Oid viewoid = PG_GETARG_OID(0);
720 int wrap = PG_GETARG_INT32(1);
721 int prettyFlags;
722 char *res;
723
724 /* calling this implies we want pretty printing */
725 prettyFlags = GET_PRETTY_FLAGS(true);
726
727 res = pg_get_viewdef_worker(viewoid, prettyFlags, wrap);
728
729 if (res == NULL)
730 PG_RETURN_NULL();
731
732 PG_RETURN_TEXT_P(string_to_text(res));
733}
734
735Datum
736pg_get_viewdef_name(PG_FUNCTION_ARGS)
737{
738 /* By qualified name */
739 text *viewname = PG_GETARG_TEXT_PP(0);
740 int prettyFlags;
741 RangeVar *viewrel;
742 Oid viewoid;
743 char *res;
744
745 prettyFlags = PRETTYFLAG_INDENT;
746
747 /* Look up view name. Can't lock it - we might not have privileges. */
748 viewrel = makeRangeVarFromNameList(textToQualifiedNameList(viewname));
749 viewoid = RangeVarGetRelid(viewrel, NoLock, false);
750
751 res = pg_get_viewdef_worker(viewoid, prettyFlags, WRAP_COLUMN_DEFAULT);
752
753 if (res == NULL)
754 PG_RETURN_NULL();
755
756 PG_RETURN_TEXT_P(string_to_text(res));
757}
758
759
760Datum
761pg_get_viewdef_name_ext(PG_FUNCTION_ARGS)
762{
763 /* By qualified name */
764 text *viewname = PG_GETARG_TEXT_PP(0);
765 bool pretty = PG_GETARG_BOOL(1);
766 int prettyFlags;
767 RangeVar *viewrel;
768 Oid viewoid;
769 char *res;
770
771 prettyFlags = GET_PRETTY_FLAGS(pretty);
772
773 /* Look up view name. Can't lock it - we might not have privileges. */
774 viewrel = makeRangeVarFromNameList(textToQualifiedNameList(viewname));
775 viewoid = RangeVarGetRelid(viewrel, NoLock, false);
776
777 res = pg_get_viewdef_worker(viewoid, prettyFlags, WRAP_COLUMN_DEFAULT);
778
779 if (res == NULL)
780 PG_RETURN_NULL();
781
782 PG_RETURN_TEXT_P(string_to_text(res));
783}
784
785/*
786 * Common code for by-OID and by-name variants of pg_get_viewdef
787 */
788static char *
789pg_get_viewdef_worker(Oid viewoid, int prettyFlags, int wrapColumn)
790{
791 Datum args[2];
792 char nulls[2];
793 int spirc;
794 HeapTuple ruletup;
795 TupleDesc rulettc;
796 StringInfoData buf;
797
798 /*
799 * Do this first so that string is alloc'd in outer context not SPI's.
800 */
801 initStringInfo(&buf);
802
803 /*
804 * Connect to SPI manager
805 */
806 SPI_connect();
807
808 /*
809 * On the first call prepare the plan to lookup pg_rewrite. We read
810 * pg_rewrite over the SPI manager instead of using the syscache to be
811 * checked for read access on pg_rewrite.
812 */
813 if (plan_getviewrule == NULL)
814 {
815 Oid argtypes[2];
816 SPIPlanPtr plan;
817
818 argtypes[0] = OIDOID;
819 argtypes[1] = NAMEOID;
820 plan = SPI_prepare(query_getviewrule, 2, argtypes);
821 if (plan == NULL)
822 elog(ERROR, "SPI_prepare failed for \"%s\"", query_getviewrule);
823 SPI_keepplan(plan);
824 plan_getviewrule = plan;
825 }
826
827 /*
828 * Get the pg_rewrite tuple for the view's SELECT rule
829 */
830 args[0] = ObjectIdGetDatum(viewoid);
831 args[1] = DirectFunctionCall1(namein, CStringGetDatum(ViewSelectRuleName));
832 nulls[0] = ' ';
833 nulls[1] = ' ';
834 spirc = SPI_execute_plan(plan_getviewrule, args, nulls, true, 0);
835 if (spirc != SPI_OK_SELECT)
836 elog(ERROR, "failed to get pg_rewrite tuple for view %u", viewoid);
837 if (SPI_processed != 1)
838 {
839 /*
840 * There is no tuple data available here, just keep the output buffer
841 * empty.
842 */
843 }
844 else
845 {
846 /*
847 * Get the rule's definition and put it into executor's memory
848 */
849 ruletup = SPI_tuptable->vals[0];
850 rulettc = SPI_tuptable->tupdesc;
851 make_viewdef(&buf, ruletup, rulettc, prettyFlags, wrapColumn);
852 }
853
854 /*
855 * Disconnect from SPI manager
856 */
857 if (SPI_finish() != SPI_OK_FINISH)
858 elog(ERROR, "SPI_finish failed");
859
860 if (buf.len == 0)
861 return NULL;
862
863 return buf.data;
864}
865
866/* ----------
867 * pg_get_triggerdef - Get the definition of a trigger
868 * ----------
869 */
870Datum
871pg_get_triggerdef(PG_FUNCTION_ARGS)
872{
873 Oid trigid = PG_GETARG_OID(0);
874 char *res;
875
876 res = pg_get_triggerdef_worker(trigid, false);
877
878 if (res == NULL)
879 PG_RETURN_NULL();
880
881 PG_RETURN_TEXT_P(string_to_text(res));
882}
883
884Datum
885pg_get_triggerdef_ext(PG_FUNCTION_ARGS)
886{
887 Oid trigid = PG_GETARG_OID(0);
888 bool pretty = PG_GETARG_BOOL(1);
889 char *res;
890
891 res = pg_get_triggerdef_worker(trigid, pretty);
892
893 if (res == NULL)
894 PG_RETURN_NULL();
895
896 PG_RETURN_TEXT_P(string_to_text(res));
897}
898
899static char *
900pg_get_triggerdef_worker(Oid trigid, bool pretty)
901{
902 HeapTuple ht_trig;
903 Form_pg_trigger trigrec;
904 StringInfoData buf;
905 Relation tgrel;
906 ScanKeyData skey[1];
907 SysScanDesc tgscan;
908 int findx = 0;
909 char *tgname;
910 char *tgoldtable;
911 char *tgnewtable;
912 Datum value;
913 bool isnull;
914
915 /*
916 * Fetch the pg_trigger tuple by the Oid of the trigger
917 */
918 tgrel = table_open(TriggerRelationId, AccessShareLock);
919
920 ScanKeyInit(&skey[0],
921 Anum_pg_trigger_oid,
922 BTEqualStrategyNumber, F_OIDEQ,
923 ObjectIdGetDatum(trigid));
924
925 tgscan = systable_beginscan(tgrel, TriggerOidIndexId, true,
926 NULL, 1, skey);
927
928 ht_trig = systable_getnext(tgscan);
929
930 if (!HeapTupleIsValid(ht_trig))
931 {
932 systable_endscan(tgscan);
933 table_close(tgrel, AccessShareLock);
934 return NULL;
935 }
936
937 trigrec = (Form_pg_trigger) GETSTRUCT(ht_trig);
938
939 /*
940 * Start the trigger definition. Note that the trigger's name should never
941 * be schema-qualified, but the trigger rel's name may be.
942 */
943 initStringInfo(&buf);
944
945 tgname = NameStr(trigrec->tgname);
946 appendStringInfo(&buf, "CREATE %sTRIGGER %s ",
947 OidIsValid(trigrec->tgconstraint) ? "CONSTRAINT " : "",
948 quote_identifier(tgname));
949
950 if (TRIGGER_FOR_BEFORE(trigrec->tgtype))
951 appendStringInfoString(&buf, "BEFORE");
952 else if (TRIGGER_FOR_AFTER(trigrec->tgtype))
953 appendStringInfoString(&buf, "AFTER");
954 else if (TRIGGER_FOR_INSTEAD(trigrec->tgtype))
955 appendStringInfoString(&buf, "INSTEAD OF");
956 else
957 elog(ERROR, "unexpected tgtype value: %d", trigrec->tgtype);
958
959 if (TRIGGER_FOR_INSERT(trigrec->tgtype))
960 {
961 appendStringInfoString(&buf, " INSERT");
962 findx++;
963 }
964 if (TRIGGER_FOR_DELETE(trigrec->tgtype))
965 {
966 if (findx > 0)
967 appendStringInfoString(&buf, " OR DELETE");
968 else
969 appendStringInfoString(&buf, " DELETE");
970 findx++;
971 }
972 if (TRIGGER_FOR_UPDATE(trigrec->tgtype))
973 {
974 if (findx > 0)
975 appendStringInfoString(&buf, " OR UPDATE");
976 else
977 appendStringInfoString(&buf, " UPDATE");
978 findx++;
979 /* tgattr is first var-width field, so OK to access directly */
980 if (trigrec->tgattr.dim1 > 0)
981 {
982 int i;
983
984 appendStringInfoString(&buf, " OF ");
985 for (i = 0; i < trigrec->tgattr.dim1; i++)
986 {
987 char *attname;
988
989 if (i > 0)
990 appendStringInfoString(&buf, ", ");
991 attname = get_attname(trigrec->tgrelid,
992 trigrec->tgattr.values[i], false);
993 appendStringInfoString(&buf, quote_identifier(attname));
994 }
995 }
996 }
997 if (TRIGGER_FOR_TRUNCATE(trigrec->tgtype))
998 {
999 if (findx > 0)
1000 appendStringInfoString(&buf, " OR TRUNCATE");
1001 else
1002 appendStringInfoString(&buf, " TRUNCATE");
1003 findx++;
1004 }
1005
1006 /*
1007 * In non-pretty mode, always schema-qualify the target table name for
1008 * safety. In pretty mode, schema-qualify only if not visible.
1009 */
1010 appendStringInfo(&buf, " ON %s ",
1011 pretty ?
1012 generate_relation_name(trigrec->tgrelid, NIL) :
1013 generate_qualified_relation_name(trigrec->tgrelid));
1014
1015 if (OidIsValid(trigrec->tgconstraint))
1016 {
1017 if (OidIsValid(trigrec->tgconstrrelid))
1018 appendStringInfo(&buf, "FROM %s ",
1019 generate_relation_name(trigrec->tgconstrrelid, NIL));
1020 if (!trigrec->tgdeferrable)
1021 appendStringInfoString(&buf, "NOT ");
1022 appendStringInfoString(&buf, "DEFERRABLE INITIALLY ");
1023 if (trigrec->tginitdeferred)
1024 appendStringInfoString(&buf, "DEFERRED ");
1025 else
1026 appendStringInfoString(&buf, "IMMEDIATE ");
1027 }
1028
1029 value = fastgetattr(ht_trig, Anum_pg_trigger_tgoldtable,
1030 tgrel->rd_att, &isnull);
1031 if (!isnull)
1032 tgoldtable = NameStr(*DatumGetName(value));
1033 else
1034 tgoldtable = NULL;
1035 value = fastgetattr(ht_trig, Anum_pg_trigger_tgnewtable,
1036 tgrel->rd_att, &isnull);
1037 if (!isnull)
1038 tgnewtable = NameStr(*DatumGetName(value));
1039 else
1040 tgnewtable = NULL;
1041 if (tgoldtable != NULL || tgnewtable != NULL)
1042 {
1043 appendStringInfoString(&buf, "REFERENCING ");
1044 if (tgoldtable != NULL)
1045 appendStringInfo(&buf, "OLD TABLE AS %s ",
1046 quote_identifier(tgoldtable));
1047 if (tgnewtable != NULL)
1048 appendStringInfo(&buf, "NEW TABLE AS %s ",
1049 quote_identifier(tgnewtable));
1050 }
1051
1052 if (TRIGGER_FOR_ROW(trigrec->tgtype))
1053 appendStringInfoString(&buf, "FOR EACH ROW ");
1054 else
1055 appendStringInfoString(&buf, "FOR EACH STATEMENT ");
1056
1057 /* If the trigger has a WHEN qualification, add that */
1058 value = fastgetattr(ht_trig, Anum_pg_trigger_tgqual,
1059 tgrel->rd_att, &isnull);
1060 if (!isnull)
1061 {
1062 Node *qual;
1063 char relkind;
1064 deparse_context context;
1065 deparse_namespace dpns;
1066 RangeTblEntry *oldrte;
1067 RangeTblEntry *newrte;
1068
1069 appendStringInfoString(&buf, "WHEN (");
1070
1071 qual = stringToNode(TextDatumGetCString(value));
1072
1073 relkind = get_rel_relkind(trigrec->tgrelid);
1074
1075 /* Build minimal OLD and NEW RTEs for the rel */
1076 oldrte = makeNode(RangeTblEntry);
1077 oldrte->rtekind = RTE_RELATION;
1078 oldrte->relid = trigrec->tgrelid;
1079 oldrte->relkind = relkind;
1080 oldrte->rellockmode = AccessShareLock;
1081 oldrte->alias = makeAlias("old", NIL);
1082 oldrte->eref = oldrte->alias;
1083 oldrte->lateral = false;
1084 oldrte->inh = false;
1085 oldrte->inFromCl = true;
1086
1087 newrte = makeNode(RangeTblEntry);
1088 newrte->rtekind = RTE_RELATION;
1089 newrte->relid = trigrec->tgrelid;
1090 newrte->relkind = relkind;
1091 newrte->rellockmode = AccessShareLock;
1092 newrte->alias = makeAlias("new", NIL);
1093 newrte->eref = newrte->alias;
1094 newrte->lateral = false;
1095 newrte->inh = false;
1096 newrte->inFromCl = true;
1097
1098 /* Build two-element rtable */
1099 memset(&dpns, 0, sizeof(dpns));
1100 dpns.rtable = list_make2(oldrte, newrte);
1101 dpns.subplans = NIL;
1102 dpns.ctes = NIL;
1103 dpns.appendrels = NULL;
1104 set_rtable_names(&dpns, NIL, NULL);
1105 set_simple_column_names(&dpns);
1106
1107 /* Set up context with one-deep namespace stack */
1108 context.buf = &buf;
1109 context.namespaces = list_make1(&dpns);
1110 context.resultDesc = NULL;
1111 context.targetList = NIL;
1112 context.windowClause = NIL;
1113 context.varprefix = true;
1114 context.prettyFlags = GET_PRETTY_FLAGS(pretty);
1115 context.wrapColumn = WRAP_COLUMN_DEFAULT;
1116 context.indentLevel = PRETTYINDENT_STD;
1117 context.colNamesVisible = true;
1118 context.inGroupBy = false;
1119 context.varInOrderBy = false;
1120 context.appendparents = NULL;
1121
1122 get_rule_expr(qual, &context, false);
1123
1124 appendStringInfoString(&buf, ") ");
1125 }
1126
1127 appendStringInfo(&buf, "EXECUTE FUNCTION %s(",
1128 generate_function_name(trigrec->tgfoid, 0,
1129 NIL, NULL,
1130 false, NULL, false));
1131
1132 if (trigrec->tgnargs > 0)
1133 {
1134 char *p;
1135 int i;
1136
1137 value = fastgetattr(ht_trig, Anum_pg_trigger_tgargs,
1138 tgrel->rd_att, &isnull);
1139 if (isnull)
1140 elog(ERROR, "tgargs is null for trigger %u", trigid);
1141 p = (char *) VARDATA_ANY(DatumGetByteaPP(value));
1142 for (i = 0; i < trigrec->tgnargs; i++)
1143 {
1144 if (i > 0)
1145 appendStringInfoString(&buf, ", ");
1146 simple_quote_literal(&buf, p);
1147 /* advance p to next string embedded in tgargs */
1148 while (*p)
1149 p++;
1150 p++;
1151 }
1152 }
1153
1154 /* We deliberately do not put semi-colon at end */
1155 appendStringInfoChar(&buf, ')');
1156
1157 /* Clean up */
1158 systable_endscan(tgscan);
1159
1160 table_close(tgrel, AccessShareLock);
1161
1162 return buf.data;
1163}
1164
1165/* ----------
1166 * pg_get_indexdef - Get the definition of an index
1167 *
1168 * In the extended version, there is a colno argument as well as pretty bool.
1169 * if colno == 0, we want a complete index definition.
1170 * if colno > 0, we only want the Nth index key's variable or expression.
1171 *
1172 * Note that the SQL-function versions of this omit any info about the
1173 * index tablespace; this is intentional because pg_dump wants it that way.
1174 * However pg_get_indexdef_string() includes the index tablespace.
1175 * ----------
1176 */
1177Datum
1178pg_get_indexdef(PG_FUNCTION_ARGS)
1179{
1180 Oid indexrelid = PG_GETARG_OID(0);
1181 int prettyFlags;
1182 char *res;
1183
1184 prettyFlags = PRETTYFLAG_INDENT;
1185
1186 res = pg_get_indexdef_worker(indexrelid, 0, NULL,
1187 false, false,
1188 false, false,
1189 prettyFlags, true);
1190
1191 if (res == NULL)
1192 PG_RETURN_NULL();
1193
1194 PG_RETURN_TEXT_P(string_to_text(res));
1195}
1196
1197Datum
1198pg_get_indexdef_ext(PG_FUNCTION_ARGS)
1199{
1200 Oid indexrelid = PG_GETARG_OID(0);
1201 int32 colno = PG_GETARG_INT32(1);
1202 bool pretty = PG_GETARG_BOOL(2);
1203 int prettyFlags;
1204 char *res;
1205
1206 prettyFlags = GET_PRETTY_FLAGS(pretty);
1207
1208 res = pg_get_indexdef_worker(indexrelid, colno, NULL,
1209 colno != 0, false,
1210 false, false,
1211 prettyFlags, true);
1212
1213 if (res == NULL)
1214 PG_RETURN_NULL();
1215
1216 PG_RETURN_TEXT_P(string_to_text(res));
1217}
1218
1219/*
1220 * Internal version for use by ALTER TABLE.
1221 * Includes a tablespace clause in the result.
1222 * Returns a palloc'd C string; no pretty-printing.
1223 */
1224char *
1225pg_get_indexdef_string(Oid indexrelid)
1226{
1227 return pg_get_indexdef_worker(indexrelid, 0, NULL,
1228 false, false,
1229 true, true,
1230 0, false);
1231}
1232
1233/* Internal version that just reports the key-column definitions */
1234char *
1235pg_get_indexdef_columns(Oid indexrelid, bool pretty)
1236{
1237 int prettyFlags;
1238
1239 prettyFlags = GET_PRETTY_FLAGS(pretty);
1240
1241 return pg_get_indexdef_worker(indexrelid, 0, NULL,
1242 true, true,
1243 false, false,
1244 prettyFlags, false);
1245}
1246
1247/* Internal version, extensible with flags to control its behavior */
1248char *
1249pg_get_indexdef_columns_extended(Oid indexrelid, bits16 flags)
1250{
1251 bool pretty = ((flags & RULE_INDEXDEF_PRETTY) != 0);
1252 bool keys_only = ((flags & RULE_INDEXDEF_KEYS_ONLY) != 0);
1253 int prettyFlags;
1254
1255 prettyFlags = GET_PRETTY_FLAGS(pretty);
1256
1257 return pg_get_indexdef_worker(indexrelid, 0, NULL,
1258 true, keys_only,
1259 false, false,
1260 prettyFlags, false);
1261}
1262
1263/*
1264 * Internal workhorse to decompile an index definition.
1265 *
1266 * This is now used for exclusion constraints as well: if excludeOps is not
1267 * NULL then it points to an array of exclusion operator OIDs.
1268 */
1269static char *
1270pg_get_indexdef_worker(Oid indexrelid, int colno,
1271 const Oid *excludeOps,
1272 bool attrsOnly, bool keysOnly,
1273 bool showTblSpc, bool inherits,
1274 int prettyFlags, bool missing_ok)
1275{
1276 /* might want a separate isConstraint parameter later */
1277 bool isConstraint = (excludeOps != NULL);
1278 HeapTuple ht_idx;
1279 HeapTuple ht_idxrel;
1280 HeapTuple ht_am;
1281 Form_pg_index idxrec;
1282 Form_pg_class idxrelrec;
1283 Form_pg_am amrec;
1284 IndexAmRoutine *amroutine;
1285 List *indexprs;
1286 ListCell *indexpr_item;
1287 List *context;
1288 Oid indrelid;
1289 int keyno;
1290 Datum indcollDatum;
1291 Datum indclassDatum;
1292 Datum indoptionDatum;
1293 oidvector *indcollation;
1294 oidvector *indclass;
1295 int2vector *indoption;
1296 StringInfoData buf;
1297 char *str;
1298 char *sep;
1299
1300 /*
1301 * Fetch the pg_index tuple by the Oid of the index
1302 */
1303 ht_idx = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexrelid));
1304 if (!HeapTupleIsValid(ht_idx))
1305 {
1306 if (missing_ok)
1307 return NULL;
1308 elog(ERROR, "cache lookup failed for index %u", indexrelid);
1309 }
1310 idxrec = (Form_pg_index) GETSTRUCT(ht_idx);
1311
1312 indrelid = idxrec->indrelid;
1313 Assert(indexrelid == idxrec->indexrelid);
1314
1315 /* Must get indcollation, indclass, and indoption the hard way */
1316 indcollDatum = SysCacheGetAttrNotNull(INDEXRELID, ht_idx,
1317 Anum_pg_index_indcollation);
1318 indcollation = (oidvector *) DatumGetPointer(indcollDatum);
1319
1320 indclassDatum = SysCacheGetAttrNotNull(INDEXRELID, ht_idx,
1321 Anum_pg_index_indclass);
1322 indclass = (oidvector *) DatumGetPointer(indclassDatum);
1323
1324 indoptionDatum = SysCacheGetAttrNotNull(INDEXRELID, ht_idx,
1325 Anum_pg_index_indoption);
1326 indoption = (int2vector *) DatumGetPointer(indoptionDatum);
1327
1328 /*
1329 * Fetch the pg_class tuple of the index relation
1330 */
1331 ht_idxrel = SearchSysCache1(RELOID, ObjectIdGetDatum(indexrelid));
1332 if (!HeapTupleIsValid(ht_idxrel))
1333 elog(ERROR, "cache lookup failed for relation %u", indexrelid);
1334 idxrelrec = (Form_pg_class) GETSTRUCT(ht_idxrel);
1335
1336 /*
1337 * Fetch the pg_am tuple of the index' access method
1338 */
1339 ht_am = SearchSysCache1(AMOID, ObjectIdGetDatum(idxrelrec->relam));
1340 if (!HeapTupleIsValid(ht_am))
1341 elog(ERROR, "cache lookup failed for access method %u",
1342 idxrelrec->relam);
1343 amrec = (Form_pg_am) GETSTRUCT(ht_am);
1344
1345 /* Fetch the index AM's API struct */
1346 amroutine = GetIndexAmRoutine(amrec->amhandler);
1347
1348 /*
1349 * Get the index expressions, if any. (NOTE: we do not use the relcache
1350 * versions of the expressions and predicate, because we want to display
1351 * non-const-folded expressions.)
1352 */
1353 if (!heap_attisnull(ht_idx, Anum_pg_index_indexprs, NULL))
1354 {
1355 Datum exprsDatum;
1356 char *exprsString;
1357
1358 exprsDatum = SysCacheGetAttrNotNull(INDEXRELID, ht_idx,
1359 Anum_pg_index_indexprs);
1360 exprsString = TextDatumGetCString(exprsDatum);
1361 indexprs = (List *) stringToNode(exprsString);
1362 pfree(exprsString);
1363 }
1364 else
1365 indexprs = NIL;
1366
1367 indexpr_item = list_head(indexprs);
1368
1369 context = deparse_context_for(get_relation_name(indrelid), indrelid);
1370
1371 /*
1372 * Start the index definition. Note that the index's name should never be
1373 * schema-qualified, but the indexed rel's name may be.
1374 */
1375 initStringInfo(&buf);
1376
1377 if (!attrsOnly)
1378 {
1379 if (!isConstraint)
1380 appendStringInfo(&buf, "CREATE %sINDEX %s ON %s%s USING %s (",
1381 idxrec->indisunique ? "UNIQUE " : "",
1382 quote_identifier(NameStr(idxrelrec->relname)),
1383 idxrelrec->relkind == RELKIND_PARTITIONED_INDEX
1384 && !inherits ? "ONLY " : "",
1385 (prettyFlags & PRETTYFLAG_SCHEMA) ?
1386 generate_relation_name(indrelid, NIL) :
1387 generate_qualified_relation_name(indrelid),
1388 quote_identifier(NameStr(amrec->amname)));
1389 else /* currently, must be EXCLUDE constraint */
1390 appendStringInfo(&buf, "EXCLUDE USING %s (",
1391 quote_identifier(NameStr(amrec->amname)));
1392 }
1393
1394 /*
1395 * Report the indexed attributes
1396 */
1397 sep = "";
1398 for (keyno = 0; keyno < idxrec->indnatts; keyno++)
1399 {
1400 AttrNumber attnum = idxrec->indkey.values[keyno];
1401 Oid keycoltype;
1402 Oid keycolcollation;
1403
1404 /*
1405 * Ignore non-key attributes if told to.
1406 */
1407 if (keysOnly && keyno >= idxrec->indnkeyatts)
1408 break;
1409
1410 /* Otherwise, print INCLUDE to divide key and non-key attrs. */
1411 if (!colno && keyno == idxrec->indnkeyatts)
1412 {
1413 appendStringInfoString(&buf, ") INCLUDE (");
1414 sep = "";
1415 }
1416
1417 if (!colno)
1418 appendStringInfoString(&buf, sep);
1419 sep = ", ";
1420
1421 if (attnum != 0)
1422 {
1423 /* Simple index column */
1424 char *attname;
1425 int32 keycoltypmod;
1426
1427 attname = get_attname(indrelid, attnum, false);
1428 if (!colno || colno == keyno + 1)
1429 appendStringInfoString(&buf, quote_identifier(attname));
1430 get_atttypetypmodcoll(indrelid, attnum,
1431 &keycoltype, &keycoltypmod,
1432 &keycolcollation);
1433 }
1434 else
1435 {
1436 /* expressional index */
1437 Node *indexkey;
1438
1439 if (indexpr_item == NULL)
1440 elog(ERROR, "too few entries in indexprs list");
1441 indexkey = (Node *) lfirst(indexpr_item);
1442 indexpr_item = lnext(indexprs, indexpr_item);
1443 /* Deparse */
1444 str = deparse_expression_pretty(indexkey, context, false, false,
1445 prettyFlags, 0);
1446 if (!colno || colno == keyno + 1)
1447 {
1448 /* Need parens if it's not a bare function call */
1449 if (looks_like_function(indexkey))
1450 appendStringInfoString(&buf, str);
1451 else
1452 appendStringInfo(&buf, "(%s)", str);
1453 }
1454 keycoltype = exprType(indexkey);
1455 keycolcollation = exprCollation(indexkey);
1456 }
1457
1458 /* Print additional decoration for (selected) key columns */
1459 if (!attrsOnly && keyno < idxrec->indnkeyatts &&
1460 (!colno || colno == keyno + 1))
1461 {
1462 int16 opt = indoption->values[keyno];
1463 Oid indcoll = indcollation->values[keyno];
1464 Datum attoptions = get_attoptions(indexrelid, keyno + 1);
1465 bool has_options = attoptions != (Datum) 0;
1466
1467 /* Add collation, if not default for column */
1468 if (OidIsValid(indcoll) && indcoll != keycolcollation)
1469 appendStringInfo(&buf, " COLLATE %s",
1470 generate_collation_name((indcoll)));
1471
1472 /* Add the operator class name, if not default */
1473 get_opclass_name(indclass->values[keyno],
1474 has_options ? InvalidOid : keycoltype, &buf);
1475
1476 if (has_options)
1477 {
1478 appendStringInfoString(&buf, " (");
1479 get_reloptions(&buf, attoptions);
1480 appendStringInfoChar(&buf, ')');
1481 }
1482
1483 /* Add options if relevant */
1484 if (amroutine->amcanorder)
1485 {
1486 /* if it supports sort ordering, report DESC and NULLS opts */
1487 if (opt & INDOPTION_DESC)
1488 {
1489 appendStringInfoString(&buf, " DESC");
1490 /* NULLS FIRST is the default in this case */
1491 if (!(opt & INDOPTION_NULLS_FIRST))
1492 appendStringInfoString(&buf, " NULLS LAST");
1493 }
1494 else
1495 {
1496 if (opt & INDOPTION_NULLS_FIRST)
1497 appendStringInfoString(&buf, " NULLS FIRST");
1498 }
1499 }
1500
1501 /* Add the exclusion operator if relevant */
1502 if (excludeOps != NULL)
1503 appendStringInfo(&buf, " WITH %s",
1504 generate_operator_name(excludeOps[keyno],
1505 keycoltype,
1506 keycoltype));
1507 }
1508 }
1509
1510 if (!attrsOnly)
1511 {
1512 appendStringInfoChar(&buf, ')');
1513
1514 if (idxrec->indnullsnotdistinct)
1515 appendStringInfoString(&buf, " NULLS NOT DISTINCT");
1516
1517 /*
1518 * If it has options, append "WITH (options)"
1519 */
1520 str = flatten_reloptions(indexrelid);
1521 if (str)
1522 {
1523 appendStringInfo(&buf, " WITH (%s)", str);
1524 pfree(str);
1525 }
1526
1527 /*
1528 * Print tablespace, but only if requested
1529 */
1530 if (showTblSpc)
1531 {
1532 Oid tblspc;
1533
1534 tblspc = get_rel_tablespace(indexrelid);
1535 if (OidIsValid(tblspc))
1536 {
1537 if (isConstraint)
1538 appendStringInfoString(&buf, " USING INDEX");
1539 appendStringInfo(&buf, " TABLESPACE %s",
1540 quote_identifier(get_tablespace_name(tblspc)));
1541 }
1542 }
1543
1544 /*
1545 * If it's a partial index, decompile and append the predicate
1546 */
1547 if (!heap_attisnull(ht_idx, Anum_pg_index_indpred, NULL))
1548 {
1549 Node *node;
1550 Datum predDatum;
1551 char *predString;
1552
1553 /* Convert text string to node tree */
1554 predDatum = SysCacheGetAttrNotNull(INDEXRELID, ht_idx,
1555 Anum_pg_index_indpred);
1556 predString = TextDatumGetCString(predDatum);
1557 node = (Node *) stringToNode(predString);
1558 pfree(predString);
1559
1560 /* Deparse */
1561 str = deparse_expression_pretty(node, context, false, false,
1562 prettyFlags, 0);
1563 if (isConstraint)
1564 appendStringInfo(&buf, " WHERE (%s)", str);
1565 else
1566 appendStringInfo(&buf, " WHERE %s", str);
1567 }
1568 }
1569
1570 /* Clean up */
1571 ReleaseSysCache(ht_idx);
1572 ReleaseSysCache(ht_idxrel);
1573 ReleaseSysCache(ht_am);
1574
1575 return buf.data;
1576}
1577
1578/* ----------
1579 * pg_get_querydef
1580 *
1581 * Public entry point to deparse one query parsetree.
1582 * The pretty flags are determined by GET_PRETTY_FLAGS(pretty).
1583 *
1584 * The result is a palloc'd C string.
1585 * ----------
1586 */
1587char *
1588pg_get_querydef(Query *query, bool pretty)
1589{
1590 StringInfoData buf;
1591 int prettyFlags;
1592
1593 prettyFlags = GET_PRETTY_FLAGS(pretty);
1594
1595 initStringInfo(&buf);
1596
1597 get_query_def(query, &buf, NIL, NULL, true,
1598 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
1599
1600 return buf.data;
1601}
1602
1603/*
1604 * pg_get_statisticsobjdef
1605 * Get the definition of an extended statistics object
1606 */
1607Datum
1608pg_get_statisticsobjdef(PG_FUNCTION_ARGS)
1609{
1610 Oid statextid = PG_GETARG_OID(0);
1611 char *res;
1612
1613 res = pg_get_statisticsobj_worker(statextid, false, true);
1614
1615 if (res == NULL)
1616 PG_RETURN_NULL();
1617
1618 PG_RETURN_TEXT_P(string_to_text(res));
1619}
1620
1621/*
1622 * Internal version for use by ALTER TABLE.
1623 * Returns a palloc'd C string; no pretty-printing.
1624 */
1625char *
1626pg_get_statisticsobjdef_string(Oid statextid)
1627{
1628 return pg_get_statisticsobj_worker(statextid, false, false);
1629}
1630
1631/*
1632 * pg_get_statisticsobjdef_columns
1633 * Get columns and expressions for an extended statistics object
1634 */
1635Datum
1636pg_get_statisticsobjdef_columns(PG_FUNCTION_ARGS)
1637{
1638 Oid statextid = PG_GETARG_OID(0);
1639 char *res;
1640
1641 res = pg_get_statisticsobj_worker(statextid, true, true);
1642
1643 if (res == NULL)
1644 PG_RETURN_NULL();
1645
1646 PG_RETURN_TEXT_P(string_to_text(res));
1647}
1648
1649/*
1650 * Internal workhorse to decompile an extended statistics object.
1651 */
1652static char *
1653pg_get_statisticsobj_worker(Oid statextid, bool columns_only, bool missing_ok)
1654{
1655 Form_pg_statistic_ext statextrec;
1656 HeapTuple statexttup;
1657 StringInfoData buf;
1658 int colno;
1659 char *nsp;
1660 ArrayType *arr;
1661 char *enabled;
1662 Datum datum;
1663 bool ndistinct_enabled;
1664 bool dependencies_enabled;
1665 bool mcv_enabled;
1666 int i;
1667 List *context;
1668 ListCell *lc;
1669 List *exprs = NIL;
1670 bool has_exprs;
1671 int ncolumns;
1672
1673 statexttup = SearchSysCache1(STATEXTOID, ObjectIdGetDatum(statextid));
1674
1675 if (!HeapTupleIsValid(statexttup))
1676 {
1677 if (missing_ok)
1678 return NULL;
1679 elog(ERROR, "cache lookup failed for statistics object %u", statextid);
1680 }
1681
1682 /* has the statistics expressions? */
1683 has_exprs = !heap_attisnull(statexttup, Anum_pg_statistic_ext_stxexprs, NULL);
1684
1685 statextrec = (Form_pg_statistic_ext) GETSTRUCT(statexttup);
1686
1687 /*
1688 * Get the statistics expressions, if any. (NOTE: we do not use the
1689 * relcache versions of the expressions, because we want to display
1690 * non-const-folded expressions.)
1691 */
1692 if (has_exprs)
1693 {
1694 Datum exprsDatum;
1695 char *exprsString;
1696
1697 exprsDatum = SysCacheGetAttrNotNull(STATEXTOID, statexttup,
1698 Anum_pg_statistic_ext_stxexprs);
1699 exprsString = TextDatumGetCString(exprsDatum);
1700 exprs = (List *) stringToNode(exprsString);
1701 pfree(exprsString);
1702 }
1703 else
1704 exprs = NIL;
1705
1706 /* count the number of columns (attributes and expressions) */
1707 ncolumns = statextrec->stxkeys.dim1 + list_length(exprs);
1708
1709 initStringInfo(&buf);
1710
1711 if (!columns_only)
1712 {
1713 nsp = get_namespace_name_or_temp(statextrec->stxnamespace);
1714 appendStringInfo(&buf, "CREATE STATISTICS %s",
1715 quote_qualified_identifier(nsp,
1716 NameStr(statextrec->stxname)));
1717
1718 /*
1719 * Decode the stxkind column so that we know which stats types to
1720 * print.
1721 */
1722 datum = SysCacheGetAttrNotNull(STATEXTOID, statexttup,
1723 Anum_pg_statistic_ext_stxkind);
1724 arr = DatumGetArrayTypeP(datum);
1725 if (ARR_NDIM(arr) != 1 ||
1726 ARR_HASNULL(arr) ||
1727 ARR_ELEMTYPE(arr) != CHAROID)
1728 elog(ERROR, "stxkind is not a 1-D char array");
1729 enabled = (char *) ARR_DATA_PTR(arr);
1730
1731 ndistinct_enabled = false;
1732 dependencies_enabled = false;
1733 mcv_enabled = false;
1734
1735 for (i = 0; i < ARR_DIMS(arr)[0]; i++)
1736 {
1737 if (enabled[i] == STATS_EXT_NDISTINCT)
1738 ndistinct_enabled = true;
1739 else if (enabled[i] == STATS_EXT_DEPENDENCIES)
1740 dependencies_enabled = true;
1741 else if (enabled[i] == STATS_EXT_MCV)
1742 mcv_enabled = true;
1743
1744 /* ignore STATS_EXT_EXPRESSIONS (it's built automatically) */
1745 }
1746
1747 /*
1748 * If any option is disabled, then we'll need to append the types
1749 * clause to show which options are enabled. We omit the types clause
1750 * on purpose when all options are enabled, so a pg_dump/pg_restore
1751 * will create all statistics types on a newer postgres version, if
1752 * the statistics had all options enabled on the original version.
1753 *
1754 * But if the statistics is defined on just a single column, it has to
1755 * be an expression statistics. In that case we don't need to specify
1756 * kinds.
1757 */
1758 if ((!ndistinct_enabled || !dependencies_enabled || !mcv_enabled) &&
1759 (ncolumns > 1))
1760 {
1761 bool gotone = false;
1762
1763 appendStringInfoString(&buf, " (");
1764
1765 if (ndistinct_enabled)
1766 {
1767 appendStringInfoString(&buf, "ndistinct");
1768 gotone = true;
1769 }
1770
1771 if (dependencies_enabled)
1772 {
1773 appendStringInfo(&buf, "%sdependencies", gotone ? ", " : "");
1774 gotone = true;
1775 }
1776
1777 if (mcv_enabled)
1778 appendStringInfo(&buf, "%smcv", gotone ? ", " : "");
1779
1780 appendStringInfoChar(&buf, ')');
1781 }
1782
1783 appendStringInfoString(&buf, " ON ");
1784 }
1785
1786 /* decode simple column references */
1787 for (colno = 0; colno < statextrec->stxkeys.dim1; colno++)
1788 {
1789 AttrNumber attnum = statextrec->stxkeys.values[colno];
1790 char *attname;
1791
1792 if (colno > 0)
1793 appendStringInfoString(&buf, ", ");
1794
1795 attname = get_attname(statextrec->stxrelid, attnum, false);
1796
1797 appendStringInfoString(&buf, quote_identifier(attname));
1798 }
1799
1800 context = deparse_context_for(get_relation_name(statextrec->stxrelid),
1801 statextrec->stxrelid);
1802
1803 foreach(lc, exprs)
1804 {
1805 Node *expr = (Node *) lfirst(lc);
1806 char *str;
1807 int prettyFlags = PRETTYFLAG_PAREN;
1808
1809 str = deparse_expression_pretty(expr, context, false, false,
1810 prettyFlags, 0);
1811
1812 if (colno > 0)
1813 appendStringInfoString(&buf, ", ");
1814
1815 /* Need parens if it's not a bare function call */
1816 if (looks_like_function(expr))
1817 appendStringInfoString(&buf, str);
1818 else
1819 appendStringInfo(&buf, "(%s)", str);
1820
1821 colno++;
1822 }
1823
1824 if (!columns_only)
1825 appendStringInfo(&buf, " FROM %s",
1826 generate_relation_name(statextrec->stxrelid, NIL));
1827
1828 ReleaseSysCache(statexttup);
1829
1830 return buf.data;
1831}
1832
1833/*
1834 * Generate text array of expressions for statistics object.
1835 */
1836Datum
1837pg_get_statisticsobjdef_expressions(PG_FUNCTION_ARGS)
1838{
1839 Oid statextid = PG_GETARG_OID(0);
1840 Form_pg_statistic_ext statextrec;
1841 HeapTuple statexttup;
1842 Datum datum;
1843 List *context;
1844 ListCell *lc;
1845 List *exprs = NIL;
1846 bool has_exprs;
1847 char *tmp;
1848 ArrayBuildState *astate = NULL;
1849
1850 statexttup = SearchSysCache1(STATEXTOID, ObjectIdGetDatum(statextid));
1851
1852 if (!HeapTupleIsValid(statexttup))
1853 PG_RETURN_NULL();
1854
1855 /* Does the stats object have expressions? */
1856 has_exprs = !heap_attisnull(statexttup, Anum_pg_statistic_ext_stxexprs, NULL);
1857
1858 /* no expressions? we're done */
1859 if (!has_exprs)
1860 {
1861 ReleaseSysCache(statexttup);
1862 PG_RETURN_NULL();
1863 }
1864
1865 statextrec = (Form_pg_statistic_ext) GETSTRUCT(statexttup);
1866
1867 /*
1868 * Get the statistics expressions, and deparse them into text values.
1869 */
1870 datum = SysCacheGetAttrNotNull(STATEXTOID, statexttup,
1871 Anum_pg_statistic_ext_stxexprs);
1872 tmp = TextDatumGetCString(datum);
1873 exprs = (List *) stringToNode(tmp);
1874 pfree(tmp);
1875
1876 context = deparse_context_for(get_relation_name(statextrec->stxrelid),
1877 statextrec->stxrelid);
1878
1879 foreach(lc, exprs)
1880 {
1881 Node *expr = (Node *) lfirst(lc);
1882 char *str;
1883 int prettyFlags = PRETTYFLAG_INDENT;
1884
1885 str = deparse_expression_pretty(expr, context, false, false,
1886 prettyFlags, 0);
1887
1888 astate = accumArrayResult(astate,
1889 PointerGetDatum(cstring_to_text(str)),
1890 false,
1891 TEXTOID,
1892 CurrentMemoryContext);
1893 }
1894
1895 ReleaseSysCache(statexttup);
1896
1897 PG_RETURN_DATUM(makeArrayResult(astate, CurrentMemoryContext));
1898}
1899
1900/*
1901 * pg_get_partkeydef
1902 *
1903 * Returns the partition key specification, ie, the following:
1904 *
1905 * { RANGE | LIST | HASH } (column opt_collation opt_opclass [, ...])
1906 */
1907Datum
1908pg_get_partkeydef(PG_FUNCTION_ARGS)
1909{
1910 Oid relid = PG_GETARG_OID(0);
1911 char *res;
1912
1913 res = pg_get_partkeydef_worker(relid, PRETTYFLAG_INDENT, false, true);
1914
1915 if (res == NULL)
1916 PG_RETURN_NULL();
1917
1918 PG_RETURN_TEXT_P(string_to_text(res));
1919}
1920
1921/* Internal version that just reports the column definitions */
1922char *
1923pg_get_partkeydef_columns(Oid relid, bool pretty)
1924{
1925 int prettyFlags;
1926
1927 prettyFlags = GET_PRETTY_FLAGS(pretty);
1928
1929 return pg_get_partkeydef_worker(relid, prettyFlags, true, false);
1930}
1931
1932/*
1933 * Internal workhorse to decompile a partition key definition.
1934 */
1935static char *
1936pg_get_partkeydef_worker(Oid relid, int prettyFlags,
1937 bool attrsOnly, bool missing_ok)
1938{
1939 Form_pg_partitioned_table form;
1940 HeapTuple tuple;
1941 oidvector *partclass;
1942 oidvector *partcollation;
1943 List *partexprs;
1944 ListCell *partexpr_item;
1945 List *context;
1946 Datum datum;
1947 StringInfoData buf;
1948 int keyno;
1949 char *str;
1950 char *sep;
1951
1952 tuple = SearchSysCache1(PARTRELID, ObjectIdGetDatum(relid));
1953 if (!HeapTupleIsValid(tuple))
1954 {
1955 if (missing_ok)
1956 return NULL;
1957 elog(ERROR, "cache lookup failed for partition key of %u", relid);
1958 }
1959
1960 form = (Form_pg_partitioned_table) GETSTRUCT(tuple);
1961
1962 Assert(form->partrelid == relid);
1963
1964 /* Must get partclass and partcollation the hard way */
1965 datum = SysCacheGetAttrNotNull(PARTRELID, tuple,
1966 Anum_pg_partitioned_table_partclass);
1967 partclass = (oidvector *) DatumGetPointer(datum);
1968
1969 datum = SysCacheGetAttrNotNull(PARTRELID, tuple,
1970 Anum_pg_partitioned_table_partcollation);
1971 partcollation = (oidvector *) DatumGetPointer(datum);
1972
1973
1974 /*
1975 * Get the expressions, if any. (NOTE: we do not use the relcache
1976 * versions of the expressions, because we want to display
1977 * non-const-folded expressions.)
1978 */
1979 if (!heap_attisnull(tuple, Anum_pg_partitioned_table_partexprs, NULL))
1980 {
1981 Datum exprsDatum;
1982 char *exprsString;
1983
1984 exprsDatum = SysCacheGetAttrNotNull(PARTRELID, tuple,
1985 Anum_pg_partitioned_table_partexprs);
1986 exprsString = TextDatumGetCString(exprsDatum);
1987 partexprs = (List *) stringToNode(exprsString);
1988
1989 if (!IsA(partexprs, List))
1990 elog(ERROR, "unexpected node type found in partexprs: %d",
1991 (int) nodeTag(partexprs));
1992
1993 pfree(exprsString);
1994 }
1995 else
1996 partexprs = NIL;
1997
1998 partexpr_item = list_head(partexprs);
1999 context = deparse_context_for(get_relation_name(relid), relid);
2000
2001 initStringInfo(&buf);
2002
2003 switch (form->partstrat)
2004 {
2005 case PARTITION_STRATEGY_HASH:
2006 if (!attrsOnly)
2007 appendStringInfoString(&buf, "HASH");
2008 break;
2009 case PARTITION_STRATEGY_LIST:
2010 if (!attrsOnly)
2011 appendStringInfoString(&buf, "LIST");
2012 break;
2013 case PARTITION_STRATEGY_RANGE:
2014 if (!attrsOnly)
2015 appendStringInfoString(&buf, "RANGE");
2016 break;
2017 default:
2018 elog(ERROR, "unexpected partition strategy: %d",
2019 (int) form->partstrat);
2020 }
2021
2022 if (!attrsOnly)
2023 appendStringInfoString(&buf, " (");
2024 sep = "";
2025 for (keyno = 0; keyno < form->partnatts; keyno++)
2026 {
2027 AttrNumber attnum = form->partattrs.values[keyno];
2028 Oid keycoltype;
2029 Oid keycolcollation;
2030 Oid partcoll;
2031
2032 appendStringInfoString(&buf, sep);
2033 sep = ", ";
2034 if (attnum != 0)
2035 {
2036 /* Simple attribute reference */
2037 char *attname;
2038 int32 keycoltypmod;
2039
2040 attname = get_attname(relid, attnum, false);
2041 appendStringInfoString(&buf, quote_identifier(attname));
2042 get_atttypetypmodcoll(relid, attnum,
2043 &keycoltype, &keycoltypmod,
2044 &keycolcollation);
2045 }
2046 else
2047 {
2048 /* Expression */
2049 Node *partkey;
2050
2051 if (partexpr_item == NULL)
2052 elog(ERROR, "too few entries in partexprs list");
2053 partkey = (Node *) lfirst(partexpr_item);
2054 partexpr_item = lnext(partexprs, partexpr_item);
2055
2056 /* Deparse */
2057 str = deparse_expression_pretty(partkey, context, false, false,
2058 prettyFlags, 0);
2059 /* Need parens if it's not a bare function call */
2060 if (looks_like_function(partkey))
2061 appendStringInfoString(&buf, str);
2062 else
2063 appendStringInfo(&buf, "(%s)", str);
2064
2065 keycoltype = exprType(partkey);
2066 keycolcollation = exprCollation(partkey);
2067 }
2068
2069 /* Add collation, if not default for column */
2070 partcoll = partcollation->values[keyno];
2071 if (!attrsOnly && OidIsValid(partcoll) && partcoll != keycolcollation)
2072 appendStringInfo(&buf, " COLLATE %s",
2073 generate_collation_name((partcoll)));
2074
2075 /* Add the operator class name, if not default */
2076 if (!attrsOnly)
2077 get_opclass_name(partclass->values[keyno], keycoltype, &buf);
2078 }
2079
2080 if (!attrsOnly)
2081 appendStringInfoChar(&buf, ')');
2082
2083 /* Clean up */
2084 ReleaseSysCache(tuple);
2085
2086 return buf.data;
2087}
2088
2089/*
2090 * pg_get_partition_constraintdef
2091 *
2092 * Returns partition constraint expression as a string for the input relation
2093 */
2094Datum
2095pg_get_partition_constraintdef(PG_FUNCTION_ARGS)
2096{
2097 Oid relationId = PG_GETARG_OID(0);
2098 Expr *constr_expr;
2099 int prettyFlags;
2100 List *context;
2101 char *consrc;
2102
2103 constr_expr = get_partition_qual_relid(relationId);
2104
2105 /* Quick exit if no partition constraint */
2106 if (constr_expr == NULL)
2107 PG_RETURN_NULL();
2108
2109 /*
2110 * Deparse and return the constraint expression.
2111 */
2112 prettyFlags = PRETTYFLAG_INDENT;
2113 context = deparse_context_for(get_relation_name(relationId), relationId);
2114 consrc = deparse_expression_pretty((Node *) constr_expr, context, false,
2115 false, prettyFlags, 0);
2116
2117 PG_RETURN_TEXT_P(string_to_text(consrc));
2118}
2119
2120/*
2121 * pg_get_partconstrdef_string
2122 *
2123 * Returns the partition constraint as a C-string for the input relation, with
2124 * the given alias. No pretty-printing.
2125 */
2126char *
2127pg_get_partconstrdef_string(Oid partitionId, char *aliasname)
2128{
2129 Expr *constr_expr;
2130 List *context;
2131
2132 constr_expr = get_partition_qual_relid(partitionId);
2133 context = deparse_context_for(aliasname, partitionId);
2134
2135 return deparse_expression((Node *) constr_expr, context, true, false);
2136}
2137
2138/*
2139 * pg_get_constraintdef
2140 *
2141 * Returns the definition for the constraint, ie, everything that needs to
2142 * appear after "ALTER TABLE ... ADD CONSTRAINT <constraintname>".
2143 */
2144Datum
2145pg_get_constraintdef(PG_FUNCTION_ARGS)
2146{
2147 Oid constraintId = PG_GETARG_OID(0);
2148 int prettyFlags;
2149 char *res;
2150
2151 prettyFlags = PRETTYFLAG_INDENT;
2152
2153 res = pg_get_constraintdef_worker(constraintId, false, prettyFlags, true);
2154
2155 if (res == NULL)
2156 PG_RETURN_NULL();
2157
2158 PG_RETURN_TEXT_P(string_to_text(res));
2159}
2160
2161Datum
2162pg_get_constraintdef_ext(PG_FUNCTION_ARGS)
2163{
2164 Oid constraintId = PG_GETARG_OID(0);
2165 bool pretty = PG_GETARG_BOOL(1);
2166 int prettyFlags;
2167 char *res;
2168
2169 prettyFlags = GET_PRETTY_FLAGS(pretty);
2170
2171 res = pg_get_constraintdef_worker(constraintId, false, prettyFlags, true);
2172
2173 if (res == NULL)
2174 PG_RETURN_NULL();
2175
2176 PG_RETURN_TEXT_P(string_to_text(res));
2177}
2178
2179/*
2180 * Internal version that returns a full ALTER TABLE ... ADD CONSTRAINT command
2181 */
2182char *
2183pg_get_constraintdef_command(Oid constraintId)
2184{
2185 return pg_get_constraintdef_worker(constraintId, true, 0, false);
2186}
2187
2188/*
2189 * As of 9.4, we now use an MVCC snapshot for this.
2190 */
2191static char *
2192pg_get_constraintdef_worker(Oid constraintId, bool fullCommand,
2193 int prettyFlags, bool missing_ok)
2194{
2195 HeapTuple tup;
2196 Form_pg_constraint conForm;
2197 StringInfoData buf;
2198 SysScanDesc scandesc;
2199 ScanKeyData scankey[1];
2200 Snapshot snapshot = RegisterSnapshot(GetTransactionSnapshot());
2201 Relation relation = table_open(ConstraintRelationId, AccessShareLock);
2202
2203 ScanKeyInit(&scankey[0],
2204 Anum_pg_constraint_oid,
2205 BTEqualStrategyNumber, F_OIDEQ,
2206 ObjectIdGetDatum(constraintId));
2207
2208 scandesc = systable_beginscan(relation,
2209 ConstraintOidIndexId,
2210 true,
2211 snapshot,
2212 1,
2213 scankey);
2214
2215 /*
2216 * We later use the tuple with SysCacheGetAttr() as if we had obtained it
2217 * via SearchSysCache, which works fine.
2218 */
2219 tup = systable_getnext(scandesc);
2220
2221 UnregisterSnapshot(snapshot);
2222
2223 if (!HeapTupleIsValid(tup))
2224 {
2225 if (missing_ok)
2226 {
2227 systable_endscan(scandesc);
2228 table_close(relation, AccessShareLock);
2229 return NULL;
2230 }
2231 elog(ERROR, "could not find tuple for constraint %u", constraintId);
2232 }
2233
2234 conForm = (Form_pg_constraint) GETSTRUCT(tup);
2235
2236 initStringInfo(&buf);
2237
2238 if (fullCommand)
2239 {
2240 if (OidIsValid(conForm->conrelid))
2241 {
2242 /*
2243 * Currently, callers want ALTER TABLE (without ONLY) for CHECK
2244 * constraints, and other types of constraints don't inherit
2245 * anyway so it doesn't matter whether we say ONLY or not. Someday
2246 * we might need to let callers specify whether to put ONLY in the
2247 * command.
2248 */
2249 appendStringInfo(&buf, "ALTER TABLE %s ADD CONSTRAINT %s ",
2250 generate_qualified_relation_name(conForm->conrelid),
2251 quote_identifier(NameStr(conForm->conname)));
2252 }
2253 else
2254 {
2255 /* Must be a domain constraint */
2256 Assert(OidIsValid(conForm->contypid));
2257 appendStringInfo(&buf, "ALTER DOMAIN %s ADD CONSTRAINT %s ",
2258 generate_qualified_type_name(conForm->contypid),
2259 quote_identifier(NameStr(conForm->conname)));
2260 }
2261 }
2262
2263 switch (conForm->contype)
2264 {
2265 case CONSTRAINT_FOREIGN:
2266 {
2267 Datum val;
2268 bool isnull;
2269 const char *string;
2270
2271 /* Start off the constraint definition */
2272 appendStringInfoString(&buf, "FOREIGN KEY (");
2273
2274 /* Fetch and build referencing-column list */
2275 val = SysCacheGetAttrNotNull(CONSTROID, tup,
2276 Anum_pg_constraint_conkey);
2277
2278 /* If it is a temporal foreign key then it uses PERIOD. */
2279 decompile_column_index_array(val, conForm->conrelid, conForm->conperiod, &buf);
2280
2281 /* add foreign relation name */
2282 appendStringInfo(&buf, ") REFERENCES %s(",
2283 generate_relation_name(conForm->confrelid,
2284 NIL));
2285
2286 /* Fetch and build referenced-column list */
2287 val = SysCacheGetAttrNotNull(CONSTROID, tup,
2288 Anum_pg_constraint_confkey);
2289
2290 decompile_column_index_array(val, conForm->confrelid, conForm->conperiod, &buf);
2291
2292 appendStringInfoChar(&buf, ')');
2293
2294 /* Add match type */
2295 switch (conForm->confmatchtype)
2296 {
2297 case FKCONSTR_MATCH_FULL:
2298 string = " MATCH FULL";
2299 break;
2300 case FKCONSTR_MATCH_PARTIAL:
2301 string = " MATCH PARTIAL";
2302 break;
2303 case FKCONSTR_MATCH_SIMPLE:
2304 string = "";
2305 break;
2306 default:
2307 elog(ERROR, "unrecognized confmatchtype: %d",
2308 conForm->confmatchtype);
2309 string = ""; /* keep compiler quiet */
2310 break;
2311 }
2312 appendStringInfoString(&buf, string);
2313
2314 /* Add ON UPDATE and ON DELETE clauses, if needed */
2315 switch (conForm->confupdtype)
2316 {
2317 case FKCONSTR_ACTION_NOACTION:
2318 string = NULL; /* suppress default */
2319 break;
2320 case FKCONSTR_ACTION_RESTRICT:
2321 string = "RESTRICT";
2322 break;
2323 case FKCONSTR_ACTION_CASCADE:
2324 string = "CASCADE";
2325 break;
2326 case FKCONSTR_ACTION_SETNULL:
2327 string = "SET NULL";
2328 break;
2329 case FKCONSTR_ACTION_SETDEFAULT:
2330 string = "SET DEFAULT";
2331 break;
2332 default:
2333 elog(ERROR, "unrecognized confupdtype: %d",
2334 conForm->confupdtype);
2335 string = NULL; /* keep compiler quiet */
2336 break;
2337 }
2338 if (string)
2339 appendStringInfo(&buf, " ON UPDATE %s", string);
2340
2341 switch (conForm->confdeltype)
2342 {
2343 case FKCONSTR_ACTION_NOACTION:
2344 string = NULL; /* suppress default */
2345 break;
2346 case FKCONSTR_ACTION_RESTRICT:
2347 string = "RESTRICT";
2348 break;
2349 case FKCONSTR_ACTION_CASCADE:
2350 string = "CASCADE";
2351 break;
2352 case FKCONSTR_ACTION_SETNULL:
2353 string = "SET NULL";
2354 break;
2355 case FKCONSTR_ACTION_SETDEFAULT:
2356 string = "SET DEFAULT";
2357 break;
2358 default:
2359 elog(ERROR, "unrecognized confdeltype: %d",
2360 conForm->confdeltype);
2361 string = NULL; /* keep compiler quiet */
2362 break;
2363 }
2364 if (string)
2365 appendStringInfo(&buf, " ON DELETE %s", string);
2366
2367 /*
2368 * Add columns specified to SET NULL or SET DEFAULT if
2369 * provided.
2370 */
2371 val = SysCacheGetAttr(CONSTROID, tup,
2372 Anum_pg_constraint_confdelsetcols, &isnull);
2373 if (!isnull)
2374 {
2375 appendStringInfoString(&buf, " (");
2376 decompile_column_index_array(val, conForm->conrelid, false, &buf);
2377 appendStringInfoChar(&buf, ')');
2378 }
2379
2380 break;
2381 }
2382 case CONSTRAINT_PRIMARY:
2383 case CONSTRAINT_UNIQUE:
2384 {
2385 Datum val;
2386 Oid indexId;
2387 int keyatts;
2388 HeapTuple indtup;
2389
2390 /* Start off the constraint definition */
2391 if (conForm->contype == CONSTRAINT_PRIMARY)
2392 appendStringInfoString(&buf, "PRIMARY KEY ");
2393 else
2394 appendStringInfoString(&buf, "UNIQUE ");
2395
2396 indexId = conForm->conindid;
2397
2398 indtup = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexId));
2399 if (!HeapTupleIsValid(indtup))
2400 elog(ERROR, "cache lookup failed for index %u", indexId);
2401 if (conForm->contype == CONSTRAINT_UNIQUE &&
2402 ((Form_pg_index) GETSTRUCT(indtup))->indnullsnotdistinct)
2403 appendStringInfoString(&buf, "NULLS NOT DISTINCT ");
2404
2405 appendStringInfoChar(&buf, '(');
2406
2407 /* Fetch and build target column list */
2408 val = SysCacheGetAttrNotNull(CONSTROID, tup,
2409 Anum_pg_constraint_conkey);
2410
2411 keyatts = decompile_column_index_array(val, conForm->conrelid, false, &buf);
2412 if (conForm->conperiod)
2413 appendStringInfoString(&buf, " WITHOUT OVERLAPS");
2414
2415 appendStringInfoChar(&buf, ')');
2416
2417 /* Build including column list (from pg_index.indkeys) */
2418 val = SysCacheGetAttrNotNull(INDEXRELID, indtup,
2419 Anum_pg_index_indnatts);
2420 if (DatumGetInt32(val) > keyatts)
2421 {
2422 Datum cols;
2423 Datum *keys;
2424 int nKeys;
2425 int j;
2426
2427 appendStringInfoString(&buf, " INCLUDE (");
2428
2429 cols = SysCacheGetAttrNotNull(INDEXRELID, indtup,
2430 Anum_pg_index_indkey);
2431
2432 deconstruct_array_builtin(DatumGetArrayTypeP(cols), INT2OID,
2433 &keys, NULL, &nKeys);
2434
2435 for (j = keyatts; j < nKeys; j++)
2436 {
2437 char *colName;
2438
2439 colName = get_attname(conForm->conrelid,
2440 DatumGetInt16(keys[j]), false);
2441 if (j > keyatts)
2442 appendStringInfoString(&buf, ", ");
2443 appendStringInfoString(&buf, quote_identifier(colName));
2444 }
2445
2446 appendStringInfoChar(&buf, ')');
2447 }
2448 ReleaseSysCache(indtup);
2449
2450 /* XXX why do we only print these bits if fullCommand? */
2451 if (fullCommand && OidIsValid(indexId))
2452 {
2453 char *options = flatten_reloptions(indexId);
2454 Oid tblspc;
2455
2456 if (options)
2457 {
2458 appendStringInfo(&buf, " WITH (%s)", options);
2459 pfree(options);
2460 }
2461
2462 /*
2463 * Print the tablespace, unless it's the database default.
2464 * This is to help ALTER TABLE usage of this facility,
2465 * which needs this behavior to recreate exact catalog
2466 * state.
2467 */
2468 tblspc = get_rel_tablespace(indexId);
2469 if (OidIsValid(tblspc))
2470 appendStringInfo(&buf, " USING INDEX TABLESPACE %s",
2471 quote_identifier(get_tablespace_name(tblspc)));
2472 }
2473
2474 break;
2475 }
2476 case CONSTRAINT_CHECK:
2477 {
2478 Datum val;
2479 char *conbin;
2480 char *consrc;
2481 Node *expr;
2482 List *context;
2483
2484 /* Fetch constraint expression in parsetree form */
2485 val = SysCacheGetAttrNotNull(CONSTROID, tup,
2486 Anum_pg_constraint_conbin);
2487
2488 conbin = TextDatumGetCString(val);
2489 expr = stringToNode(conbin);
2490
2491 /* Set up deparsing context for Var nodes in constraint */
2492 if (conForm->conrelid != InvalidOid)
2493 {
2494 /* relation constraint */
2495 context = deparse_context_for(get_relation_name(conForm->conrelid),
2496 conForm->conrelid);
2497 }
2498 else
2499 {
2500 /* domain constraint --- can't have Vars */
2501 context = NIL;
2502 }
2503
2504 consrc = deparse_expression_pretty(expr, context, false, false,
2505 prettyFlags, 0);
2506
2507 /*
2508 * Now emit the constraint definition, adding NO INHERIT if
2509 * necessary.
2510 *
2511 * There are cases where the constraint expression will be
2512 * fully parenthesized and we don't need the outer parens ...
2513 * but there are other cases where we do need 'em. Be
2514 * conservative for now.
2515 *
2516 * Note that simply checking for leading '(' and trailing ')'
2517 * would NOT be good enough, consider "(x > 0) AND (y > 0)".
2518 */
2519 appendStringInfo(&buf, "CHECK (%s)%s",
2520 consrc,
2521 conForm->connoinherit ? " NO INHERIT" : "");
2522 break;
2523 }
2524 case CONSTRAINT_NOTNULL:
2525 {
2526 if (conForm->conrelid)
2527 {
2528 AttrNumber attnum;
2529
2530 attnum = extractNotNullColumn(tup);
2531
2532 appendStringInfo(&buf, "NOT NULL %s",
2533 quote_identifier(get_attname(conForm->conrelid,
2534 attnum, false)));
2535 if (((Form_pg_constraint) GETSTRUCT(tup))->connoinherit)
2536 appendStringInfoString(&buf, " NO INHERIT");
2537 }
2538 else if (conForm->contypid)
2539 {
2540 /* conkey is null for domain not-null constraints */
2541 appendStringInfoString(&buf, "NOT NULL");
2542 }
2543 break;
2544 }
2545
2546 case CONSTRAINT_TRIGGER:
2547
2548 /*
2549 * There isn't an ALTER TABLE syntax for creating a user-defined
2550 * constraint trigger, but it seems better to print something than
2551 * throw an error; if we throw error then this function couldn't
2552 * safely be applied to all rows of pg_constraint.
2553 */
2554 appendStringInfoString(&buf, "TRIGGER");
2555 break;
2556 case CONSTRAINT_EXCLUSION:
2557 {
2558 Oid indexOid = conForm->conindid;
2559 Datum val;
2560 Datum *elems;
2561 int nElems;
2562 int i;
2563 Oid *operators;
2564
2565 /* Extract operator OIDs from the pg_constraint tuple */
2566 val = SysCacheGetAttrNotNull(CONSTROID, tup,
2567 Anum_pg_constraint_conexclop);
2568
2569 deconstruct_array_builtin(DatumGetArrayTypeP(val), OIDOID,
2570 &elems, NULL, &nElems);
2571
2572 operators = (Oid *) palloc(nElems * sizeof(Oid));
2573 for (i = 0; i < nElems; i++)
2574 operators[i] = DatumGetObjectId(elems[i]);
2575
2576 /* pg_get_indexdef_worker does the rest */
2577 /* suppress tablespace because pg_dump wants it that way */
2578 appendStringInfoString(&buf,
2579 pg_get_indexdef_worker(indexOid,
2580 0,
2581 operators,
2582 false,
2583 false,
2584 false,
2585 false,
2586 prettyFlags,
2587 false));
2588 break;
2589 }
2590 default:
2591 elog(ERROR, "invalid constraint type \"%c\"", conForm->contype);
2592 break;
2593 }
2594
2595 if (conForm->condeferrable)
2596 appendStringInfoString(&buf, " DEFERRABLE");
2597 if (conForm->condeferred)
2598 appendStringInfoString(&buf, " INITIALLY DEFERRED");
2599
2600 /* Validated status is irrelevant when the constraint is NOT ENFORCED. */
2601 if (!conForm->conenforced)
2602 appendStringInfoString(&buf, " NOT ENFORCED");
2603 else if (!conForm->convalidated)
2604 appendStringInfoString(&buf, " NOT VALID");
2605
2606 /* Cleanup */
2607 systable_endscan(scandesc);
2608 table_close(relation, AccessShareLock);
2609
2610 return buf.data;
2611}
2612
2613
2614/*
2615 * Convert an int16[] Datum into a comma-separated list of column names
2616 * for the indicated relation; append the list to buf. Returns the number
2617 * of keys.
2618 */
2619static int
2620decompile_column_index_array(Datum column_index_array, Oid relId,
2621 bool withPeriod, StringInfo buf)
2622{
2623 Datum *keys;
2624 int nKeys;
2625 int j;
2626
2627 /* Extract data from array of int16 */
2628 deconstruct_array_builtin(DatumGetArrayTypeP(column_index_array), INT2OID,
2629 &keys, NULL, &nKeys);
2630
2631 for (j = 0; j < nKeys; j++)
2632 {
2633 char *colName;
2634
2635 colName = get_attname(relId, DatumGetInt16(keys[j]), false);
2636
2637 if (j == 0)
2638 appendStringInfoString(buf, quote_identifier(colName));
2639 else
2640 appendStringInfo(buf, ", %s%s",
2641 (withPeriod && j == nKeys - 1) ? "PERIOD " : "",
2642 quote_identifier(colName));
2643 }
2644
2645 return nKeys;
2646}
2647
2648
2649/* ----------
2650 * pg_get_expr - Decompile an expression tree
2651 *
2652 * Input: an expression tree in nodeToString form, and a relation OID
2653 *
2654 * Output: reverse-listed expression
2655 *
2656 * Currently, the expression can only refer to a single relation, namely
2657 * the one specified by the second parameter. This is sufficient for
2658 * partial indexes, column default expressions, etc. We also support
2659 * Var-free expressions, for which the OID can be InvalidOid.
2660 *
2661 * If the OID is nonzero but not actually valid, don't throw an error,
2662 * just return NULL. This is a bit questionable, but it's what we've
2663 * done historically, and it can help avoid unwanted failures when
2664 * examining catalog entries for just-deleted relations.
2665 *
2666 * We expect this function to work, or throw a reasonably clean error,
2667 * for any node tree that can appear in a catalog pg_node_tree column.
2668 * Query trees, such as those appearing in pg_rewrite.ev_action, are
2669 * not supported. Nor are expressions in more than one relation, which
2670 * can appear in places like pg_rewrite.ev_qual.
2671 * ----------
2672 */
2673Datum
2674pg_get_expr(PG_FUNCTION_ARGS)
2675{
2676 text *expr = PG_GETARG_TEXT_PP(0);
2677 Oid relid = PG_GETARG_OID(1);
2678 text *result;
2679 int prettyFlags;
2680
2681 prettyFlags = PRETTYFLAG_INDENT;
2682
2683 result = pg_get_expr_worker(expr, relid, prettyFlags);
2684 if (result)
2685 PG_RETURN_TEXT_P(result);
2686 else
2687 PG_RETURN_NULL();
2688}
2689
2690Datum
2691pg_get_expr_ext(PG_FUNCTION_ARGS)
2692{
2693 text *expr = PG_GETARG_TEXT_PP(0);
2694 Oid relid = PG_GETARG_OID(1);
2695 bool pretty = PG_GETARG_BOOL(2);
2696 text *result;
2697 int prettyFlags;
2698
2699 prettyFlags = GET_PRETTY_FLAGS(pretty);
2700
2701 result = pg_get_expr_worker(expr, relid, prettyFlags);
2702 if (result)
2703 PG_RETURN_TEXT_P(result);
2704 else
2705 PG_RETURN_NULL();
2706}
2707
2708static text *
2709pg_get_expr_worker(text *expr, Oid relid, int prettyFlags)
2710{
2711 Node *node;
2712 Node *tst;
2713 Relids relids;
2714 List *context;
2715 char *exprstr;
2716 Relation rel = NULL;
2717 char *str;
2718
2719 /* Convert input pg_node_tree (really TEXT) object to C string */
2720 exprstr = text_to_cstring(expr);
2721
2722 /* Convert expression to node tree */
2723 node = (Node *) stringToNode(exprstr);
2724
2725 pfree(exprstr);
2726
2727 /*
2728 * Throw error if the input is a querytree rather than an expression tree.
2729 * While we could support queries here, there seems no very good reason
2730 * to. In most such catalog columns, we'll see a List of Query nodes, or
2731 * even nested Lists, so drill down to a non-List node before checking.
2732 */
2733 tst = node;
2734 while (tst && IsA(tst, List))
2735 tst = linitial((List *) tst);
2736 if (tst && IsA(tst, Query))
2737 ereport(ERROR,
2738 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2739 errmsg("input is a query, not an expression")));
2740
2741 /*
2742 * Throw error if the expression contains Vars we won't be able to
2743 * deparse.
2744 */
2745 relids = pull_varnos(NULL, node);
2746 if (OidIsValid(relid))
2747 {
2748 if (!bms_is_subset(relids, bms_make_singleton(1)))
2749 ereport(ERROR,
2750 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2751 errmsg("expression contains variables of more than one relation")));
2752 }
2753 else
2754 {
2755 if (!bms_is_empty(relids))
2756 ereport(ERROR,
2757 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2758 errmsg("expression contains variables")));
2759 }
2760
2761 /*
2762 * Prepare deparse context if needed. If we are deparsing with a relid,
2763 * we need to transiently open and lock the rel, to make sure it won't go
2764 * away underneath us. (set_relation_column_names would lock it anyway,
2765 * so this isn't really introducing any new behavior.)
2766 */
2767 if (OidIsValid(relid))
2768 {
2769 rel = try_relation_open(relid, AccessShareLock);
2770 if (rel == NULL)
2771 return NULL;
2772 context = deparse_context_for(RelationGetRelationName(rel), relid);
2773 }
2774 else
2775 context = NIL;
2776
2777 /* Deparse */
2778 str = deparse_expression_pretty(node, context, false, false,
2779 prettyFlags, 0);
2780
2781 if (rel != NULL)
2782 relation_close(rel, AccessShareLock);
2783
2784 return string_to_text(str);
2785}
2786
2787
2788/* ----------
2789 * pg_get_userbyid - Get a user name by roleid and
2790 * fallback to 'unknown (OID=n)'
2791 * ----------
2792 */
2793Datum
2794pg_get_userbyid(PG_FUNCTION_ARGS)
2795{
2796 Oid roleid = PG_GETARG_OID(0);
2797 Name result;
2798 HeapTuple roletup;
2799 Form_pg_authid role_rec;
2800
2801 /*
2802 * Allocate space for the result
2803 */
2804 result = (Name) palloc(NAMEDATALEN);
2805 memset(NameStr(*result), 0, NAMEDATALEN);
2806
2807 /*
2808 * Get the pg_authid entry and print the result
2809 */
2810 roletup = SearchSysCache1(AUTHOID, ObjectIdGetDatum(roleid));
2811 if (HeapTupleIsValid(roletup))
2812 {
2813 role_rec = (Form_pg_authid) GETSTRUCT(roletup);
2814 *result = role_rec->rolname;
2815 ReleaseSysCache(roletup);
2816 }
2817 else
2818 sprintf(NameStr(*result), "unknown (OID=%u)", roleid);
2819
2820 PG_RETURN_NAME(result);
2821}
2822
2823
2824/*
2825 * pg_get_serial_sequence
2826 * Get the name of the sequence used by an identity or serial column,
2827 * formatted suitably for passing to setval, nextval or currval.
2828 * First parameter is not treated as double-quoted, second parameter
2829 * is --- see documentation for reason.
2830 */
2831Datum
2832pg_get_serial_sequence(PG_FUNCTION_ARGS)
2833{
2834 text *tablename = PG_GETARG_TEXT_PP(0);
2835 text *columnname = PG_GETARG_TEXT_PP(1);
2836 RangeVar *tablerv;
2837 Oid tableOid;
2838 char *column;
2839 AttrNumber attnum;
2840 Oid sequenceId = InvalidOid;
2841 Relation depRel;
2842 ScanKeyData key[3];
2843 SysScanDesc scan;
2844 HeapTuple tup;
2845
2846 /* Look up table name. Can't lock it - we might not have privileges. */
2847 tablerv = makeRangeVarFromNameList(textToQualifiedNameList(tablename));
2848 tableOid = RangeVarGetRelid(tablerv, NoLock, false);
2849
2850 /* Get the number of the column */
2851 column = text_to_cstring(columnname);
2852
2853 attnum = get_attnum(tableOid, column);
2854 if (attnum == InvalidAttrNumber)
2855 ereport(ERROR,
2856 (errcode(ERRCODE_UNDEFINED_COLUMN),
2857 errmsg("column \"%s\" of relation \"%s\" does not exist",
2858 column, tablerv->relname)));
2859
2860 /* Search the dependency table for the dependent sequence */
2861 depRel = table_open(DependRelationId, AccessShareLock);
2862
2863 ScanKeyInit(&key[0],
2864 Anum_pg_depend_refclassid,
2865 BTEqualStrategyNumber, F_OIDEQ,
2866 ObjectIdGetDatum(RelationRelationId));
2867 ScanKeyInit(&key[1],
2868 Anum_pg_depend_refobjid,
2869 BTEqualStrategyNumber, F_OIDEQ,
2870 ObjectIdGetDatum(tableOid));
2871 ScanKeyInit(&key[2],
2872 Anum_pg_depend_refobjsubid,
2873 BTEqualStrategyNumber, F_INT4EQ,
2874 Int32GetDatum(attnum));
2875
2876 scan = systable_beginscan(depRel, DependReferenceIndexId, true,
2877 NULL, 3, key);
2878
2879 while (HeapTupleIsValid(tup = systable_getnext(scan)))
2880 {
2881 Form_pg_depend deprec = (Form_pg_depend) GETSTRUCT(tup);
2882
2883 /*
2884 * Look for an auto dependency (serial column) or internal dependency
2885 * (identity column) of a sequence on a column. (We need the relkind
2886 * test because indexes can also have auto dependencies on columns.)
2887 */
2888 if (deprec->classid == RelationRelationId &&
2889 deprec->objsubid == 0 &&
2890 (deprec->deptype == DEPENDENCY_AUTO ||
2891 deprec->deptype == DEPENDENCY_INTERNAL) &&
2892 get_rel_relkind(deprec->objid) == RELKIND_SEQUENCE)
2893 {
2894 sequenceId = deprec->objid;
2895 break;
2896 }
2897 }
2898
2899 systable_endscan(scan);
2900 table_close(depRel, AccessShareLock);
2901
2902 if (OidIsValid(sequenceId))
2903 {
2904 char *result;
2905
2906 result = generate_qualified_relation_name(sequenceId);
2907
2908 PG_RETURN_TEXT_P(string_to_text(result));
2909 }
2910
2911 PG_RETURN_NULL();
2912}
2913
2914
2915/*
2916 * pg_get_functiondef
2917 * Returns the complete "CREATE OR REPLACE FUNCTION ..." statement for
2918 * the specified function.
2919 *
2920 * Note: if you change the output format of this function, be careful not
2921 * to break psql's rules (in \ef and \sf) for identifying the start of the
2922 * function body. To wit: the function body starts on a line that begins with
2923 * "AS ", "BEGIN ", or "RETURN ", and no preceding line will look like that.
2924 */
2925Datum
2926pg_get_functiondef(PG_FUNCTION_ARGS)
2927{
2928 Oid funcid = PG_GETARG_OID(0);
2929 StringInfoData buf;
2930 StringInfoData dq;
2931 HeapTuple proctup;
2932 Form_pg_proc proc;
2933 bool isfunction;
2934 Datum tmp;
2935 bool isnull;
2936 const char *prosrc;
2937 const char *name;
2938 const char *nsp;
2939 float4 procost;
2940 int oldlen;
2941
2942 initStringInfo(&buf);
2943
2944 /* Look up the function */
2945 proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
2946 if (!HeapTupleIsValid(proctup))
2947 PG_RETURN_NULL();
2948
2949 proc = (Form_pg_proc) GETSTRUCT(proctup);
2950 name = NameStr(proc->proname);
2951
2952 if (proc->prokind == PROKIND_AGGREGATE)
2953 ereport(ERROR,
2954 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
2955 errmsg("\"%s\" is an aggregate function", name)));
2956
2957 isfunction = (proc->prokind != PROKIND_PROCEDURE);
2958
2959 /*
2960 * We always qualify the function name, to ensure the right function gets
2961 * replaced.
2962 */
2963 nsp = get_namespace_name_or_temp(proc->pronamespace);
2964 appendStringInfo(&buf, "CREATE OR REPLACE %s %s(",
2965 isfunction ? "FUNCTION" : "PROCEDURE",
2966 quote_qualified_identifier(nsp, name));
2967 (void) print_function_arguments(&buf, proctup, false, true);
2968 appendStringInfoString(&buf, ")\n");
2969 if (isfunction)
2970 {
2971 appendStringInfoString(&buf, " RETURNS ");
2972 print_function_rettype(&buf, proctup);
2973 appendStringInfoChar(&buf, '\n');
2974 }
2975
2976 print_function_trftypes(&buf, proctup);
2977
2978 appendStringInfo(&buf, " LANGUAGE %s\n",
2979 quote_identifier(get_language_name(proc->prolang, false)));
2980
2981 /* Emit some miscellaneous options on one line */
2982 oldlen = buf.len;
2983
2984 if (proc->prokind == PROKIND_WINDOW)
2985 appendStringInfoString(&buf, " WINDOW");
2986 switch (proc->provolatile)
2987 {
2988 case PROVOLATILE_IMMUTABLE:
2989 appendStringInfoString(&buf, " IMMUTABLE");
2990 break;
2991 case PROVOLATILE_STABLE:
2992 appendStringInfoString(&buf, " STABLE");
2993 break;
2994 case PROVOLATILE_VOLATILE:
2995 break;
2996 }
2997
2998 switch (proc->proparallel)
2999 {
3000 case PROPARALLEL_SAFE:
3001 appendStringInfoString(&buf, " PARALLEL SAFE");
3002 break;
3003 case PROPARALLEL_RESTRICTED:
3004 appendStringInfoString(&buf, " PARALLEL RESTRICTED");
3005 break;
3006 case PROPARALLEL_UNSAFE:
3007 break;
3008 }
3009
3010 if (proc->proisstrict)
3011 appendStringInfoString(&buf, " STRICT");
3012 if (proc->prosecdef)
3013 appendStringInfoString(&buf, " SECURITY DEFINER");
3014 if (proc->proleakproof)
3015 appendStringInfoString(&buf, " LEAKPROOF");
3016
3017 /* This code for the default cost and rows should match functioncmds.c */
3018 if (proc->prolang == INTERNALlanguageId ||
3019 proc->prolang == ClanguageId)
3020 procost = 1;
3021 else
3022 procost = 100;
3023 if (proc->procost != procost)
3024 appendStringInfo(&buf, " COST %g", proc->procost);
3025
3026 if (proc->prorows > 0 && proc->prorows != 1000)
3027 appendStringInfo(&buf, " ROWS %g", proc->prorows);
3028
3029 if (proc->prosupport)
3030 {
3031 Oid argtypes[1];
3032
3033 /*
3034 * We should qualify the support function's name if it wouldn't be
3035 * resolved by lookup in the current search path.
3036 */
3037 argtypes[0] = INTERNALOID;
3038 appendStringInfo(&buf, " SUPPORT %s",
3039 generate_function_name(proc->prosupport, 1,
3040 NIL, argtypes,
3041 false, NULL, false));
3042 }
3043
3044 if (oldlen != buf.len)
3045 appendStringInfoChar(&buf, '\n');
3046
3047 /* Emit any proconfig options, one per line */
3048 tmp = SysCacheGetAttr(PROCOID, proctup, Anum_pg_proc_proconfig, &isnull);
3049 if (!isnull)
3050 {
3051 ArrayType *a = DatumGetArrayTypeP(tmp);
3052 int i;
3053
3054 Assert(ARR_ELEMTYPE(a) == TEXTOID);
3055 Assert(ARR_NDIM(a) == 1);
3056 Assert(ARR_LBOUND(a)[0] == 1);
3057
3058 for (i = 1; i <= ARR_DIMS(a)[0]; i++)
3059 {
3060 Datum d;
3061
3062 d = array_ref(a, 1, &i,
3063 -1 /* varlenarray */ ,
3064 -1 /* TEXT's typlen */ ,
3065 false /* TEXT's typbyval */ ,
3066 TYPALIGN_INT /* TEXT's typalign */ ,
3067 &isnull);
3068 if (!isnull)
3069 {
3070 char *configitem = TextDatumGetCString(d);
3071 char *pos;
3072
3073 pos = strchr(configitem, '=');
3074 if (pos == NULL)
3075 continue;
3076 *pos++ = '\0';
3077
3078 appendStringInfo(&buf, " SET %s TO ",
3079 quote_identifier(configitem));
3080
3081 /*
3082 * Variables that are marked GUC_LIST_QUOTE were already fully
3083 * quoted by flatten_set_variable_args() before they were put
3084 * into the proconfig array. However, because the quoting
3085 * rules used there aren't exactly like SQL's, we have to
3086 * break the list value apart and then quote the elements as
3087 * string literals. (The elements may be double-quoted as-is,
3088 * but we can't just feed them to the SQL parser; it would do
3089 * the wrong thing with elements that are zero-length or
3090 * longer than NAMEDATALEN.) Also, we need a special case for
3091 * empty lists.
3092 *
3093 * Variables that are not so marked should just be emitted as
3094 * simple string literals. If the variable is not known to
3095 * guc.c, we'll do that; this makes it unsafe to use
3096 * GUC_LIST_QUOTE for extension variables.
3097 */
3098 if (GetConfigOptionFlags(configitem, true) & GUC_LIST_QUOTE)
3099 {
3100 List *namelist;
3101 ListCell *lc;
3102
3103 /* Parse string into list of identifiers */
3104 if (!SplitGUCList(pos, ',', &namelist))
3105 {
3106 /* this shouldn't fail really */
3107 elog(ERROR, "invalid list syntax in proconfig item");
3108 }
3109 /* Special case: represent an empty list as NULL */
3110 if (namelist == NIL)
3111 appendStringInfoString(&buf, "NULL");
3112 foreach(lc, namelist)
3113 {
3114 char *curname = (char *) lfirst(lc);
3115
3116 simple_quote_literal(&buf, curname);
3117 if (lnext(namelist, lc))
3118 appendStringInfoString(&buf, ", ");
3119 }
3120 }
3121 else
3122 simple_quote_literal(&buf, pos);
3123 appendStringInfoChar(&buf, '\n');
3124 }
3125 }
3126 }
3127
3128 /* And finally the function definition ... */
3129 (void) SysCacheGetAttr(PROCOID, proctup, Anum_pg_proc_prosqlbody, &isnull);
3130 if (proc->prolang == SQLlanguageId && !isnull)
3131 {
3132 print_function_sqlbody(&buf, proctup);
3133 }
3134 else
3135 {
3136 appendStringInfoString(&buf, "AS ");
3137
3138 tmp = SysCacheGetAttr(PROCOID, proctup, Anum_pg_proc_probin, &isnull);
3139 if (!isnull)
3140 {
3141 simple_quote_literal(&buf, TextDatumGetCString(tmp));
3142 appendStringInfoString(&buf, ", "); /* assume prosrc isn't null */
3143 }
3144
3145 tmp = SysCacheGetAttrNotNull(PROCOID, proctup, Anum_pg_proc_prosrc);
3146 prosrc = TextDatumGetCString(tmp);
3147
3148 /*
3149 * We always use dollar quoting. Figure out a suitable delimiter.
3150 *
3151 * Since the user is likely to be editing the function body string, we
3152 * shouldn't use a short delimiter that he might easily create a
3153 * conflict with. Hence prefer "$function$"/"$procedure$", but extend
3154 * if needed.
3155 */
3156 initStringInfo(&dq);
3157 appendStringInfoChar(&dq, '$');
3158 appendStringInfoString(&dq, (isfunction ? "function" : "procedure"));
3159 while (strstr(prosrc, dq.data) != NULL)
3160 appendStringInfoChar(&dq, 'x');
3161 appendStringInfoChar(&dq, '$');
3162
3163 appendBinaryStringInfo(&buf, dq.data, dq.len);
3164 appendStringInfoString(&buf, prosrc);
3165 appendBinaryStringInfo(&buf, dq.data, dq.len);
3166 }
3167
3168 appendStringInfoChar(&buf, '\n');
3169
3170 ReleaseSysCache(proctup);
3171
3172 PG_RETURN_TEXT_P(string_to_text(buf.data));
3173}
3174
3175/*
3176 * pg_get_function_arguments
3177 * Get a nicely-formatted list of arguments for a function.
3178 * This is everything that would go between the parentheses in
3179 * CREATE FUNCTION.
3180 */
3181Datum
3182pg_get_function_arguments(PG_FUNCTION_ARGS)
3183{
3184 Oid funcid = PG_GETARG_OID(0);
3185 StringInfoData buf;
3186 HeapTuple proctup;
3187
3188 proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
3189 if (!HeapTupleIsValid(proctup))
3190 PG_RETURN_NULL();
3191
3192 initStringInfo(&buf);
3193
3194 (void) print_function_arguments(&buf, proctup, false, true);
3195
3196 ReleaseSysCache(proctup);
3197
3198 PG_RETURN_TEXT_P(string_to_text(buf.data));
3199}
3200
3201/*
3202 * pg_get_function_identity_arguments
3203 * Get a formatted list of arguments for a function.
3204 * This is everything that would go between the parentheses in
3205 * ALTER FUNCTION, etc. In particular, don't print defaults.
3206 */
3207Datum
3208pg_get_function_identity_arguments(PG_FUNCTION_ARGS)
3209{
3210 Oid funcid = PG_GETARG_OID(0);
3211 StringInfoData buf;
3212 HeapTuple proctup;
3213
3214 proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
3215 if (!HeapTupleIsValid(proctup))
3216 PG_RETURN_NULL();
3217
3218 initStringInfo(&buf);
3219
3220 (void) print_function_arguments(&buf, proctup, false, false);
3221
3222 ReleaseSysCache(proctup);
3223
3224 PG_RETURN_TEXT_P(string_to_text(buf.data));
3225}
3226
3227/*
3228 * pg_get_function_result
3229 * Get a nicely-formatted version of the result type of a function.
3230 * This is what would appear after RETURNS in CREATE FUNCTION.
3231 */
3232Datum
3233pg_get_function_result(PG_FUNCTION_ARGS)
3234{
3235 Oid funcid = PG_GETARG_OID(0);
3236 StringInfoData buf;
3237 HeapTuple proctup;
3238
3239 proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
3240 if (!HeapTupleIsValid(proctup))
3241 PG_RETURN_NULL();
3242
3243 if (((Form_pg_proc) GETSTRUCT(proctup))->prokind == PROKIND_PROCEDURE)
3244 {
3245 ReleaseSysCache(proctup);
3246 PG_RETURN_NULL();
3247 }
3248
3249 initStringInfo(&buf);
3250
3251 print_function_rettype(&buf, proctup);
3252
3253 ReleaseSysCache(proctup);
3254
3255 PG_RETURN_TEXT_P(string_to_text(buf.data));
3256}
3257
3258/*
3259 * Guts of pg_get_function_result: append the function's return type
3260 * to the specified buffer.
3261 */
3262static void
3263print_function_rettype(StringInfo buf, HeapTuple proctup)
3264{
3265 Form_pg_proc proc = (Form_pg_proc) GETSTRUCT(proctup);
3266 int ntabargs = 0;
3267 StringInfoData rbuf;
3268
3269 initStringInfo(&rbuf);
3270
3271 if (proc->proretset)
3272 {
3273 /* It might be a table function; try to print the arguments */
3274 appendStringInfoString(&rbuf, "TABLE(");
3275 ntabargs = print_function_arguments(&rbuf, proctup, true, false);
3276 if (ntabargs > 0)
3277 appendStringInfoChar(&rbuf, ')');
3278 else
3279 resetStringInfo(&rbuf);
3280 }
3281
3282 if (ntabargs == 0)
3283 {
3284 /* Not a table function, so do the normal thing */
3285 if (proc->proretset)
3286 appendStringInfoString(&rbuf, "SETOF ");
3287 appendStringInfoString(&rbuf, format_type_be(proc->prorettype));
3288 }
3289
3290 appendBinaryStringInfo(buf, rbuf.data, rbuf.len);
3291}
3292
3293/*
3294 * Common code for pg_get_function_arguments and pg_get_function_result:
3295 * append the desired subset of arguments to buf. We print only TABLE
3296 * arguments when print_table_args is true, and all the others when it's false.
3297 * We print argument defaults only if print_defaults is true.
3298 * Function return value is the number of arguments printed.
3299 */
3300static int
3301print_function_arguments(StringInfo buf, HeapTuple proctup,
3302 bool print_table_args, bool print_defaults)
3303{
3304 Form_pg_proc proc = (Form_pg_proc) GETSTRUCT(proctup);
3305 int numargs;
3306 Oid *argtypes;
3307 char **argnames;
3308 char *argmodes;
3309 int insertorderbyat = -1;
3310 int argsprinted;
3311 int inputargno;
3312 int nlackdefaults;
3313 List *argdefaults = NIL;
3314 ListCell *nextargdefault = NULL;
3315 int i;
3316
3317 numargs = get_func_arg_info(proctup,
3318 &argtypes, &argnames, &argmodes);
3319
3320 nlackdefaults = numargs;
3321 if (print_defaults && proc->pronargdefaults > 0)
3322 {
3323 Datum proargdefaults;
3324 bool isnull;
3325
3326 proargdefaults = SysCacheGetAttr(PROCOID, proctup,
3327 Anum_pg_proc_proargdefaults,
3328 &isnull);
3329 if (!isnull)
3330 {
3331 char *str;
3332
3333 str = TextDatumGetCString(proargdefaults);
3334 argdefaults = castNode(List, stringToNode(str));
3335 pfree(str);
3336 nextargdefault = list_head(argdefaults);
3337 /* nlackdefaults counts only *input* arguments lacking defaults */
3338 nlackdefaults = proc->pronargs - list_length(argdefaults);
3339 }
3340 }
3341
3342 /* Check for special treatment of ordered-set aggregates */
3343 if (proc->prokind == PROKIND_AGGREGATE)
3344 {
3345 HeapTuple aggtup;
3346 Form_pg_aggregate agg;
3347
3348 aggtup = SearchSysCache1(AGGFNOID, ObjectIdGetDatum(proc->oid));
3349 if (!HeapTupleIsValid(aggtup))
3350 elog(ERROR, "cache lookup failed for aggregate %u",
3351 proc->oid);
3352 agg = (Form_pg_aggregate) GETSTRUCT(aggtup);
3353 if (AGGKIND_IS_ORDERED_SET(agg->aggkind))
3354 insertorderbyat = agg->aggnumdirectargs;
3355 ReleaseSysCache(aggtup);
3356 }
3357
3358 argsprinted = 0;
3359 inputargno = 0;
3360 for (i = 0; i < numargs; i++)
3361 {
3362 Oid argtype = argtypes[i];
3363 char *argname = argnames ? argnames[i] : NULL;
3364 char argmode = argmodes ? argmodes[i] : PROARGMODE_IN;
3365 const char *modename;
3366 bool isinput;
3367
3368 switch (argmode)
3369 {
3370 case PROARGMODE_IN:
3371
3372 /*
3373 * For procedures, explicitly mark all argument modes, so as
3374 * to avoid ambiguity with the SQL syntax for DROP PROCEDURE.
3375 */
3376 if (proc->prokind == PROKIND_PROCEDURE)
3377 modename = "IN ";
3378 else
3379 modename = "";
3380 isinput = true;
3381 break;
3382 case PROARGMODE_INOUT:
3383 modename = "INOUT ";
3384 isinput = true;
3385 break;
3386 case PROARGMODE_OUT:
3387 modename = "OUT ";
3388 isinput = false;
3389 break;
3390 case PROARGMODE_VARIADIC:
3391 modename = "VARIADIC ";
3392 isinput = true;
3393 break;
3394 case PROARGMODE_TABLE:
3395 modename = "";
3396 isinput = false;
3397 break;
3398 default:
3399 elog(ERROR, "invalid parameter mode '%c'", argmode);
3400 modename = NULL; /* keep compiler quiet */
3401 isinput = false;
3402 break;
3403 }
3404 if (isinput)
3405 inputargno++; /* this is a 1-based counter */
3406
3407 if (print_table_args != (argmode == PROARGMODE_TABLE))
3408 continue;
3409
3410 if (argsprinted == insertorderbyat)
3411 {
3412 if (argsprinted)
3413 appendStringInfoChar(buf, ' ');
3414 appendStringInfoString(buf, "ORDER BY ");
3415 }
3416 else if (argsprinted)
3417 appendStringInfoString(buf, ", ");
3418
3419 appendStringInfoString(buf, modename);
3420 if (argname && argname[0])
3421 appendStringInfo(buf, "%s ", quote_identifier(argname));
3422 appendStringInfoString(buf, format_type_be(argtype));
3423 if (print_defaults && isinput && inputargno > nlackdefaults)
3424 {
3425 Node *expr;
3426
3427 Assert(nextargdefault != NULL);
3428 expr = (Node *) lfirst(nextargdefault);
3429 nextargdefault = lnext(argdefaults, nextargdefault);
3430
3431 appendStringInfo(buf, " DEFAULT %s",
3432 deparse_expression(expr, NIL, false, false));
3433 }
3434 argsprinted++;
3435
3436 /* nasty hack: print the last arg twice for variadic ordered-set agg */
3437 if (argsprinted == insertorderbyat && i == numargs - 1)
3438 {
3439 i--;
3440 /* aggs shouldn't have defaults anyway, but just to be sure ... */
3441 print_defaults = false;
3442 }
3443 }
3444
3445 return argsprinted;
3446}
3447
3448static bool
3449is_input_argument(int nth, const char *argmodes)
3450{
3451 return (!argmodes
3452 || argmodes[nth] == PROARGMODE_IN
3453 || argmodes[nth] == PROARGMODE_INOUT
3454 || argmodes[nth] == PROARGMODE_VARIADIC);
3455}
3456
3457/*
3458 * Append used transformed types to specified buffer
3459 */
3460static void
3461print_function_trftypes(StringInfo buf, HeapTuple proctup)
3462{
3463 Oid *trftypes;
3464 int ntypes;
3465
3466 ntypes = get_func_trftypes(proctup, &trftypes);
3467 if (ntypes > 0)
3468 {
3469 int i;
3470
3471 appendStringInfoString(buf, " TRANSFORM ");
3472 for (i = 0; i < ntypes; i++)
3473 {
3474 if (i != 0)
3475 appendStringInfoString(buf, ", ");
3476 appendStringInfo(buf, "FOR TYPE %s", format_type_be(trftypes[i]));
3477 }
3478 appendStringInfoChar(buf, '\n');
3479 }
3480}
3481
3482/*
3483 * Get textual representation of a function argument's default value. The
3484 * second argument of this function is the argument number among all arguments
3485 * (i.e. proallargtypes, *not* proargtypes), starting with 1, because that's
3486 * how information_schema.sql uses it.
3487 */
3488Datum
3489pg_get_function_arg_default(PG_FUNCTION_ARGS)
3490{
3491 Oid funcid = PG_GETARG_OID(0);
3492 int32 nth_arg = PG_GETARG_INT32(1);
3493 HeapTuple proctup;
3494 Form_pg_proc proc;
3495 int numargs;
3496 Oid *argtypes;
3497 char **argnames;
3498 char *argmodes;
3499 int i;
3500 List *argdefaults;
3501 Node *node;
3502 char *str;
3503 int nth_inputarg;
3504 Datum proargdefaults;
3505 bool isnull;
3506 int nth_default;
3507
3508 proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
3509 if (!HeapTupleIsValid(proctup))
3510 PG_RETURN_NULL();
3511
3512 numargs = get_func_arg_info(proctup, &argtypes, &argnames, &argmodes);
3513 if (nth_arg < 1 || nth_arg > numargs || !is_input_argument(nth_arg - 1, argmodes))
3514 {
3515 ReleaseSysCache(proctup);
3516 PG_RETURN_NULL();
3517 }
3518
3519 nth_inputarg = 0;
3520 for (i = 0; i < nth_arg; i++)
3521 if (is_input_argument(i, argmodes))
3522 nth_inputarg++;
3523
3524 proargdefaults = SysCacheGetAttr(PROCOID, proctup,
3525 Anum_pg_proc_proargdefaults,
3526 &isnull);
3527 if (isnull)
3528 {
3529 ReleaseSysCache(proctup);
3530 PG_RETURN_NULL();
3531 }
3532
3533 str = TextDatumGetCString(proargdefaults);
3534 argdefaults = castNode(List, stringToNode(str));
3535 pfree(str);
3536
3537 proc = (Form_pg_proc) GETSTRUCT(proctup);
3538
3539 /*
3540 * Calculate index into proargdefaults: proargdefaults corresponds to the
3541 * last N input arguments, where N = pronargdefaults.
3542 */
3543 nth_default = nth_inputarg - 1 - (proc->pronargs - proc->pronargdefaults);
3544
3545 if (nth_default < 0 || nth_default >= list_length(argdefaults))
3546 {
3547 ReleaseSysCache(proctup);
3548 PG_RETURN_NULL();
3549 }
3550 node = list_nth(argdefaults, nth_default);
3551 str = deparse_expression(node, NIL, false, false);
3552
3553 ReleaseSysCache(proctup);
3554
3555 PG_RETURN_TEXT_P(string_to_text(str));
3556}
3557
3558static void
3559print_function_sqlbody(StringInfo buf, HeapTuple proctup)
3560{
3561 int numargs;
3562 Oid *argtypes;
3563 char **argnames;
3564 char *argmodes;
3565 deparse_namespace dpns = {0};
3566 Datum tmp;
3567 Node *n;
3568
3569 dpns.funcname = pstrdup(NameStr(((Form_pg_proc) GETSTRUCT(proctup))->proname));
3570 numargs = get_func_arg_info(proctup,
3571 &argtypes, &argnames, &argmodes);
3572 dpns.numargs = numargs;
3573 dpns.argnames = argnames;
3574
3575 tmp = SysCacheGetAttrNotNull(PROCOID, proctup, Anum_pg_proc_prosqlbody);
3576 n = stringToNode(TextDatumGetCString(tmp));
3577
3578 if (IsA(n, List))
3579 {
3580 List *stmts;
3581 ListCell *lc;
3582
3583 stmts = linitial(castNode(List, n));
3584
3585 appendStringInfoString(buf, "BEGIN ATOMIC\n");
3586
3587 foreach(lc, stmts)
3588 {
3589 Query *query = lfirst_node(Query, lc);
3590
3591 /* It seems advisable to get at least AccessShareLock on rels */
3592 AcquireRewriteLocks(query, false, false);
3593 get_query_def(query, buf, list_make1(&dpns), NULL, false,
3594 PRETTYFLAG_INDENT, WRAP_COLUMN_DEFAULT, 1);
3595 appendStringInfoChar(buf, ';');
3596 appendStringInfoChar(buf, '\n');
3597 }
3598
3599 appendStringInfoString(buf, "END");
3600 }
3601 else
3602 {
3603 Query *query = castNode(Query, n);
3604
3605 /* It seems advisable to get at least AccessShareLock on rels */
3606 AcquireRewriteLocks(query, false, false);
3607 get_query_def(query, buf, list_make1(&dpns), NULL, false,
3608 0, WRAP_COLUMN_DEFAULT, 0);
3609 }
3610}
3611
3612Datum
3613pg_get_function_sqlbody(PG_FUNCTION_ARGS)
3614{
3615 Oid funcid = PG_GETARG_OID(0);
3616 StringInfoData buf;
3617 HeapTuple proctup;
3618 bool isnull;
3619
3620 initStringInfo(&buf);
3621
3622 /* Look up the function */
3623 proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
3624 if (!HeapTupleIsValid(proctup))
3625 PG_RETURN_NULL();
3626
3627 (void) SysCacheGetAttr(PROCOID, proctup, Anum_pg_proc_prosqlbody, &isnull);
3628 if (isnull)
3629 {
3630 ReleaseSysCache(proctup);
3631 PG_RETURN_NULL();
3632 }
3633
3634 print_function_sqlbody(&buf, proctup);
3635
3636 ReleaseSysCache(proctup);
3637
3638 PG_RETURN_TEXT_P(cstring_to_text_with_len(buf.data, buf.len));
3639}
3640
3641
3642/*
3643 * deparse_expression - General utility for deparsing expressions
3644 *
3645 * calls deparse_expression_pretty with all prettyPrinting disabled
3646 */
3647char *
3648deparse_expression(Node *expr, List *dpcontext,
3649 bool forceprefix, bool showimplicit)
3650{
3651 return deparse_expression_pretty(expr, dpcontext, forceprefix,
3652 showimplicit, 0, 0);
3653}
3654
3655/* ----------
3656 * deparse_expression_pretty - General utility for deparsing expressions
3657 *
3658 * expr is the node tree to be deparsed. It must be a transformed expression
3659 * tree (ie, not the raw output of gram.y).
3660 *
3661 * dpcontext is a list of deparse_namespace nodes representing the context
3662 * for interpreting Vars in the node tree. It can be NIL if no Vars are
3663 * expected.
3664 *
3665 * forceprefix is true to force all Vars to be prefixed with their table names.
3666 *
3667 * showimplicit is true to force all implicit casts to be shown explicitly.
3668 *
3669 * Tries to pretty up the output according to prettyFlags and startIndent.
3670 *
3671 * The result is a palloc'd string.
3672 * ----------
3673 */
3674static char *
3675deparse_expression_pretty(Node *expr, List *dpcontext,
3676 bool forceprefix, bool showimplicit,
3677 int prettyFlags, int startIndent)
3678{
3679 StringInfoData buf;
3680 deparse_context context;
3681
3682 initStringInfo(&buf);
3683 context.buf = &buf;
3684 context.namespaces = dpcontext;
3685 context.resultDesc = NULL;
3686 context.targetList = NIL;
3687 context.windowClause = NIL;
3688 context.varprefix = forceprefix;
3689 context.prettyFlags = prettyFlags;
3690 context.wrapColumn = WRAP_COLUMN_DEFAULT;
3691 context.indentLevel = startIndent;
3692 context.colNamesVisible = true;
3693 context.inGroupBy = false;
3694 context.varInOrderBy = false;
3695 context.appendparents = NULL;
3696
3697 get_rule_expr(expr, &context, showimplicit);
3698
3699 return buf.data;
3700}
3701
3702/* ----------
3703 * deparse_context_for - Build deparse context for a single relation
3704 *
3705 * Given the reference name (alias) and OID of a relation, build deparsing
3706 * context for an expression referencing only that relation (as varno 1,
3707 * varlevelsup 0). This is sufficient for many uses of deparse_expression.
3708 * ----------
3709 */
3710List *
3711deparse_context_for(const char *aliasname, Oid relid)
3712{
3713 deparse_namespace *dpns;
3714 RangeTblEntry *rte;
3715
3716 dpns = (deparse_namespace *) palloc0(sizeof(deparse_namespace));
3717
3718 /* Build a minimal RTE for the rel */
3719 rte = makeNode(RangeTblEntry);
3720 rte->rtekind = RTE_RELATION;
3721 rte->relid = relid;
3722 rte->relkind = RELKIND_RELATION; /* no need for exactness here */
3723 rte->rellockmode = AccessShareLock;
3724 rte->alias = makeAlias(aliasname, NIL);
3725 rte->eref = rte->alias;
3726 rte->lateral = false;
3727 rte->inh = false;
3728 rte->inFromCl = true;
3729
3730 /* Build one-element rtable */
3731 dpns->rtable = list_make1(rte);
3732 dpns->subplans = NIL;
3733 dpns->ctes = NIL;
3734 dpns->appendrels = NULL;
3735 set_rtable_names(dpns, NIL, NULL);
3736 set_simple_column_names(dpns);
3737
3738 /* Return a one-deep namespace stack */
3739 return list_make1(dpns);
3740}
3741
3742/*
3743 * deparse_context_for_plan_tree - Build deparse context for a Plan tree
3744 *
3745 * When deparsing an expression in a Plan tree, we use the plan's rangetable
3746 * to resolve names of simple Vars. The initialization of column names for
3747 * this is rather expensive if the rangetable is large, and it'll be the same
3748 * for every expression in the Plan tree; so we do it just once and re-use
3749 * the result of this function for each expression. (Note that the result
3750 * is not usable until set_deparse_context_plan() is applied to it.)
3751 *
3752 * In addition to the PlannedStmt, pass the per-RTE alias names
3753 * assigned by a previous call to select_rtable_names_for_explain.
3754 */
3755List *
3756deparse_context_for_plan_tree(PlannedStmt *pstmt, List *rtable_names)
3757{
3758 deparse_namespace *dpns;
3759
3760 dpns = (deparse_namespace *) palloc0(sizeof(deparse_namespace));
3761
3762 /* Initialize fields that stay the same across the whole plan tree */
3763 dpns->rtable = pstmt->rtable;
3764 dpns->rtable_names = rtable_names;
3765 dpns->subplans = pstmt->subplans;
3766 dpns->ctes = NIL;
3767 if (pstmt->appendRelations)
3768 {
3769 /* Set up the array, indexed by child relid */
3770 int ntables = list_length(dpns->rtable);
3771 ListCell *lc;
3772
3773 dpns->appendrels = (AppendRelInfo **)
3774 palloc0((ntables + 1) * sizeof(AppendRelInfo *));
3775 foreach(lc, pstmt->appendRelations)
3776 {
3777 AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
3778 Index crelid = appinfo->child_relid;
3779
3780 Assert(crelid > 0 && crelid <= ntables);
3781 Assert(dpns->appendrels[crelid] == NULL);
3782 dpns->appendrels[crelid] = appinfo;
3783 }
3784 }
3785 else
3786 dpns->appendrels = NULL; /* don't need it */
3787
3788 /*
3789 * Set up column name aliases, ignoring any join RTEs; they don't matter
3790 * because plan trees don't contain any join alias Vars.
3791 */
3792 set_simple_column_names(dpns);
3793
3794 /* Return a one-deep namespace stack */
3795 return list_make1(dpns);
3796}
3797
3798/*
3799 * set_deparse_context_plan - Specify Plan node containing expression
3800 *
3801 * When deparsing an expression in a Plan tree, we might have to resolve
3802 * OUTER_VAR, INNER_VAR, or INDEX_VAR references. To do this, the caller must
3803 * provide the parent Plan node. Then OUTER_VAR and INNER_VAR references
3804 * can be resolved by drilling down into the left and right child plans.
3805 * Similarly, INDEX_VAR references can be resolved by reference to the
3806 * indextlist given in a parent IndexOnlyScan node, or to the scan tlist in
3807 * ForeignScan and CustomScan nodes. (Note that we don't currently support
3808 * deparsing of indexquals in regular IndexScan or BitmapIndexScan nodes;
3809 * for those, we can only deparse the indexqualorig fields, which won't
3810 * contain INDEX_VAR Vars.)
3811 *
3812 * The ancestors list is a list of the Plan's parent Plan and SubPlan nodes,
3813 * the most-closely-nested first. This is needed to resolve PARAM_EXEC
3814 * Params. Note we assume that all the Plan nodes share the same rtable.
3815 *
3816 * For a ModifyTable plan, we might also need to resolve references to OLD/NEW
3817 * variables in the RETURNING list, so we copy the alias names of the OLD and
3818 * NEW rows from the ModifyTable plan node.
3819 *
3820 * Once this function has been called, deparse_expression() can be called on
3821 * subsidiary expression(s) of the specified Plan node. To deparse
3822 * expressions of a different Plan node in the same Plan tree, re-call this
3823 * function to identify the new parent Plan node.
3824 *
3825 * The result is the same List passed in; this is a notational convenience.
3826 */
3827List *
3828set_deparse_context_plan(List *dpcontext, Plan *plan, List *ancestors)
3829{
3830 deparse_namespace *dpns;
3831
3832 /* Should always have one-entry namespace list for Plan deparsing */
3833 Assert(list_length(dpcontext) == 1);
3834 dpns = (deparse_namespace *) linitial(dpcontext);
3835
3836 /* Set our attention on the specific plan node passed in */
3837 dpns->ancestors = ancestors;
3838 set_deparse_plan(dpns, plan);
3839
3840 /* For ModifyTable, set aliases for OLD and NEW in RETURNING */
3841 if (IsA(plan, ModifyTable))
3842 {
3843 dpns->ret_old_alias = ((ModifyTable *) plan)->returningOldAlias;
3844 dpns->ret_new_alias = ((ModifyTable *) plan)->returningNewAlias;
3845 }
3846
3847 return dpcontext;
3848}
3849
3850/*
3851 * select_rtable_names_for_explain - Select RTE aliases for EXPLAIN
3852 *
3853 * Determine the relation aliases we'll use during an EXPLAIN operation.
3854 * This is just a frontend to set_rtable_names. We have to expose the aliases
3855 * to EXPLAIN because EXPLAIN needs to know the right alias names to print.
3856 */
3857List *
3858select_rtable_names_for_explain(List *rtable, Bitmapset *rels_used)
3859{
3860 deparse_namespace dpns;
3861
3862 memset(&dpns, 0, sizeof(dpns));
3863 dpns.rtable = rtable;
3864 dpns.subplans = NIL;
3865 dpns.ctes = NIL;
3866 dpns.appendrels = NULL;
3867 set_rtable_names(&dpns, NIL, rels_used);
3868 /* We needn't bother computing column aliases yet */
3869
3870 return dpns.rtable_names;
3871}
3872
3873/*
3874 * set_rtable_names: select RTE aliases to be used in printing a query
3875 *
3876 * We fill in dpns->rtable_names with a list of names that is one-for-one with
3877 * the already-filled dpns->rtable list. Each RTE name is unique among those
3878 * in the new namespace plus any ancestor namespaces listed in
3879 * parent_namespaces.
3880 *
3881 * If rels_used isn't NULL, only RTE indexes listed in it are given aliases.
3882 *
3883 * Note that this function is only concerned with relation names, not column
3884 * names.
3885 */
3886static void
3887set_rtable_names(deparse_namespace *dpns, List *parent_namespaces,
3888 Bitmapset *rels_used)
3889{
3890 HASHCTL hash_ctl;
3891 HTAB *names_hash;
3892 NameHashEntry *hentry;
3893 bool found;
3894 int rtindex;
3895 ListCell *lc;
3896
3897 dpns->rtable_names = NIL;
3898 /* nothing more to do if empty rtable */
3899 if (dpns->rtable == NIL)
3900 return;
3901
3902 /*
3903 * We use a hash table to hold known names, so that this process is O(N)
3904 * not O(N^2) for N names.
3905 */
3906 hash_ctl.keysize = NAMEDATALEN;
3907 hash_ctl.entrysize = sizeof(NameHashEntry);
3908 hash_ctl.hcxt = CurrentMemoryContext;
3909 names_hash = hash_create("set_rtable_names names",
3910 list_length(dpns->rtable),
3911 &hash_ctl,
3912 HASH_ELEM | HASH_STRINGS | HASH_CONTEXT);
3913
3914 /* Preload the hash table with names appearing in parent_namespaces */
3915 foreach(lc, parent_namespaces)
3916 {
3917 deparse_namespace *olddpns = (deparse_namespace *) lfirst(lc);
3918 ListCell *lc2;
3919
3920 foreach(lc2, olddpns->rtable_names)
3921 {
3922 char *oldname = (char *) lfirst(lc2);
3923
3924 if (oldname == NULL)
3925 continue;
3926 hentry = (NameHashEntry *) hash_search(names_hash,
3927 oldname,
3928 HASH_ENTER,
3929 &found);
3930 /* we do not complain about duplicate names in parent namespaces */
3931 hentry->counter = 0;
3932 }
3933 }
3934
3935 /* Now we can scan the rtable */
3936 rtindex = 1;
3937 foreach(lc, dpns->rtable)
3938 {
3939 RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
3940 char *refname;
3941
3942 /* Just in case this takes an unreasonable amount of time ... */
3943 CHECK_FOR_INTERRUPTS();
3944
3945 if (rels_used && !bms_is_member(rtindex, rels_used))
3946 {
3947 /* Ignore unreferenced RTE */
3948 refname = NULL;
3949 }
3950 else if (rte->alias)
3951 {
3952 /* If RTE has a user-defined alias, prefer that */
3953 refname = rte->alias->aliasname;
3954 }
3955 else if (rte->rtekind == RTE_RELATION)
3956 {
3957 /* Use the current actual name of the relation */
3958 refname = get_rel_name(rte->relid);
3959 }
3960 else if (rte->rtekind == RTE_JOIN)
3961 {
3962 /* Unnamed join has no refname */
3963 refname = NULL;
3964 }
3965 else
3966 {
3967 /* Otherwise use whatever the parser assigned */
3968 refname = rte->eref->aliasname;
3969 }
3970
3971 /*
3972 * If the selected name isn't unique, append digits to make it so, and
3973 * make a new hash entry for it once we've got a unique name. For a
3974 * very long input name, we might have to truncate to stay within
3975 * NAMEDATALEN.
3976 */
3977 if (refname)
3978 {
3979 hentry = (NameHashEntry *) hash_search(names_hash,
3980 refname,
3981 HASH_ENTER,
3982 &found);
3983 if (found)
3984 {
3985 /* Name already in use, must choose a new one */
3986 int refnamelen = strlen(refname);
3987 char *modname = (char *) palloc(refnamelen + 16);
3988 NameHashEntry *hentry2;
3989
3990 do
3991 {
3992 hentry->counter++;
3993 for (;;)
3994 {
3995 memcpy(modname, refname, refnamelen);
3996 sprintf(modname + refnamelen, "_%d", hentry->counter);
3997 if (strlen(modname) < NAMEDATALEN)
3998 break;
3999 /* drop chars from refname to keep all the digits */
4000 refnamelen = pg_mbcliplen(refname, refnamelen,
4001 refnamelen - 1);
4002 }
4003 hentry2 = (NameHashEntry *) hash_search(names_hash,
4004 modname,
4005 HASH_ENTER,
4006 &found);
4007 } while (found);
4008 hentry2->counter = 0; /* init new hash entry */
4009 refname = modname;
4010 }
4011 else
4012 {
4013 /* Name not previously used, need only initialize hentry */
4014 hentry->counter = 0;
4015 }
4016 }
4017
4018 dpns->rtable_names = lappend(dpns->rtable_names, refname);
4019 rtindex++;
4020 }
4021
4022 hash_destroy(names_hash);
4023}
4024
4025/*
4026 * set_deparse_for_query: set up deparse_namespace for deparsing a Query tree
4027 *
4028 * For convenience, this is defined to initialize the deparse_namespace struct
4029 * from scratch.
4030 */
4031static void
4032set_deparse_for_query(deparse_namespace *dpns, Query *query,
4033 List *parent_namespaces)
4034{
4035 ListCell *lc;
4036 ListCell *lc2;
4037
4038 /* Initialize *dpns and fill rtable/ctes links */
4039 memset(dpns, 0, sizeof(deparse_namespace));
4040 dpns->rtable = query->rtable;
4041 dpns->subplans = NIL;
4042 dpns->ctes = query->cteList;
4043 dpns->appendrels = NULL;
4044 dpns->ret_old_alias = query->returningOldAlias;
4045 dpns->ret_new_alias = query->returningNewAlias;
4046
4047 /* Assign a unique relation alias to each RTE */
4048 set_rtable_names(dpns, parent_namespaces, NULL);
4049
4050 /* Initialize dpns->rtable_columns to contain zeroed structs */
4051 dpns->rtable_columns = NIL;
4052 while (list_length(dpns->rtable_columns) < list_length(dpns->rtable))
4053 dpns->rtable_columns = lappend(dpns->rtable_columns,
4054 palloc0(sizeof(deparse_columns)));
4055
4056 /* If it's a utility query, it won't have a jointree */
4057 if (query->jointree)
4058 {
4059 /* Detect whether global uniqueness of USING names is needed */
4060 dpns->unique_using =
4061 has_dangerous_join_using(dpns, (Node *) query->jointree);
4062
4063 /*
4064 * Select names for columns merged by USING, via a recursive pass over
4065 * the query jointree.
4066 */
4067 set_using_names(dpns, (Node *) query->jointree, NIL);
4068 }
4069
4070 /*
4071 * Now assign remaining column aliases for each RTE. We do this in a
4072 * linear scan of the rtable, so as to process RTEs whether or not they
4073 * are in the jointree (we mustn't miss NEW.*, INSERT target relations,
4074 * etc). JOIN RTEs must be processed after their children, but this is
4075 * okay because they appear later in the rtable list than their children
4076 * (cf Asserts in identify_join_columns()).
4077 */
4078 forboth(lc, dpns->rtable, lc2, dpns->rtable_columns)
4079 {
4080 RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
4081 deparse_columns *colinfo = (deparse_columns *) lfirst(lc2);
4082
4083 if (rte->rtekind == RTE_JOIN)
4084 set_join_column_names(dpns, rte, colinfo);
4085 else
4086 set_relation_column_names(dpns, rte, colinfo);
4087 }
4088}
4089
4090/*
4091 * set_simple_column_names: fill in column aliases for non-query situations
4092 *
4093 * This handles EXPLAIN and cases where we only have relation RTEs. Without
4094 * a join tree, we can't do anything smart about join RTEs, but we don't
4095 * need to, because EXPLAIN should never see join alias Vars anyway.
4096 * If we find a join RTE we'll just skip it, leaving its deparse_columns
4097 * struct all-zero. If somehow we try to deparse a join alias Var, we'll
4098 * error out cleanly because the struct's num_cols will be zero.
4099 */
4100static void
4101set_simple_column_names(deparse_namespace *dpns)
4102{
4103 ListCell *lc;
4104 ListCell *lc2;
4105
4106 /* Initialize dpns->rtable_columns to contain zeroed structs */
4107 dpns->rtable_columns = NIL;
4108 while (list_length(dpns->rtable_columns) < list_length(dpns->rtable))
4109 dpns->rtable_columns = lappend(dpns->rtable_columns,
4110 palloc0(sizeof(deparse_columns)));
4111
4112 /* Assign unique column aliases within each non-join RTE */
4113 forboth(lc, dpns->rtable, lc2, dpns->rtable_columns)
4114 {
4115 RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
4116 deparse_columns *colinfo = (deparse_columns *) lfirst(lc2);
4117
4118 if (rte->rtekind != RTE_JOIN)
4119 set_relation_column_names(dpns, rte, colinfo);
4120 }
4121}
4122
4123/*
4124 * has_dangerous_join_using: search jointree for unnamed JOIN USING
4125 *
4126 * Merged columns of a JOIN USING may act differently from either of the input
4127 * columns, either because they are merged with COALESCE (in a FULL JOIN) or
4128 * because an implicit coercion of the underlying input column is required.
4129 * In such a case the column must be referenced as a column of the JOIN not as
4130 * a column of either input. And this is problematic if the join is unnamed
4131 * (alias-less): we cannot qualify the column's name with an RTE name, since
4132 * there is none. (Forcibly assigning an alias to the join is not a solution,
4133 * since that will prevent legal references to tables below the join.)
4134 * To ensure that every column in the query is unambiguously referenceable,
4135 * we must assign such merged columns names that are globally unique across
4136 * the whole query, aliasing other columns out of the way as necessary.
4137 *
4138 * Because the ensuing re-aliasing is fairly damaging to the readability of
4139 * the query, we don't do this unless we have to. So, we must pre-scan
4140 * the join tree to see if we have to, before starting set_using_names().
4141 */
4142static bool
4143has_dangerous_join_using(deparse_namespace *dpns, Node *jtnode)
4144{
4145 if (IsA(jtnode, RangeTblRef))
4146 {
4147 /* nothing to do here */
4148 }
4149 else if (IsA(jtnode, FromExpr))
4150 {
4151 FromExpr *f = (FromExpr *) jtnode;
4152 ListCell *lc;
4153
4154 foreach(lc, f->fromlist)
4155 {
4156 if (has_dangerous_join_using(dpns, (Node *) lfirst(lc)))
4157 return true;
4158 }
4159 }
4160 else if (IsA(jtnode, JoinExpr))
4161 {
4162 JoinExpr *j = (JoinExpr *) jtnode;
4163
4164 /* Is it an unnamed JOIN with USING? */
4165 if (j->alias == NULL && j->usingClause)
4166 {
4167 /*
4168 * Yes, so check each join alias var to see if any of them are not
4169 * simple references to underlying columns. If so, we have a
4170 * dangerous situation and must pick unique aliases.
4171 */
4172 RangeTblEntry *jrte = rt_fetch(j->rtindex, dpns->rtable);
4173
4174 /* We need only examine the merged columns */
4175 for (int i = 0; i < jrte->joinmergedcols; i++)
4176 {
4177 Node *aliasvar = list_nth(jrte->joinaliasvars, i);
4178
4179 if (!IsA(aliasvar, Var))
4180 return true;
4181 }
4182 }
4183
4184 /* Nope, but inspect children */
4185 if (has_dangerous_join_using(dpns, j->larg))
4186 return true;
4187 if (has_dangerous_join_using(dpns, j->rarg))
4188 return true;
4189 }
4190 else
4191 elog(ERROR, "unrecognized node type: %d",
4192 (int) nodeTag(jtnode));
4193 return false;
4194}
4195
4196/*
4197 * set_using_names: select column aliases to be used for merged USING columns
4198 *
4199 * We do this during a recursive descent of the query jointree.
4200 * dpns->unique_using must already be set to determine the global strategy.
4201 *
4202 * Column alias info is saved in the dpns->rtable_columns list, which is
4203 * assumed to be filled with pre-zeroed deparse_columns structs.
4204 *
4205 * parentUsing is a list of all USING aliases assigned in parent joins of
4206 * the current jointree node. (The passed-in list must not be modified.)
4207 *
4208 * Note that we do not use per-deparse_columns hash tables in this function.
4209 * The number of names that need to be assigned should be small enough that
4210 * we don't need to trouble with that.
4211 */
4212static void
4213set_using_names(deparse_namespace *dpns, Node *jtnode, List *parentUsing)
4214{
4215 if (IsA(jtnode, RangeTblRef))
4216 {
4217 /* nothing to do now */
4218 }
4219 else if (IsA(jtnode, FromExpr))
4220 {
4221 FromExpr *f = (FromExpr *) jtnode;
4222 ListCell *lc;
4223
4224 foreach(lc, f->fromlist)
4225 set_using_names(dpns, (Node *) lfirst(lc), parentUsing);
4226 }
4227 else if (IsA(jtnode, JoinExpr))
4228 {
4229 JoinExpr *j = (JoinExpr *) jtnode;
4230 RangeTblEntry *rte = rt_fetch(j->rtindex, dpns->rtable);
4231 deparse_columns *colinfo = deparse_columns_fetch(j->rtindex, dpns);
4232 int *leftattnos;
4233 int *rightattnos;
4234 deparse_columns *leftcolinfo;
4235 deparse_columns *rightcolinfo;
4236 int i;
4237 ListCell *lc;
4238
4239 /* Get info about the shape of the join */
4240 identify_join_columns(j, rte, colinfo);
4241 leftattnos = colinfo->leftattnos;
4242 rightattnos = colinfo->rightattnos;
4243
4244 /* Look up the not-yet-filled-in child deparse_columns structs */
4245 leftcolinfo = deparse_columns_fetch(colinfo->leftrti, dpns);
4246 rightcolinfo = deparse_columns_fetch(colinfo->rightrti, dpns);
4247
4248 /*
4249 * If this join is unnamed, then we cannot substitute new aliases at
4250 * this level, so any name requirements pushed down to here must be
4251 * pushed down again to the children.
4252 */
4253 if (rte->alias == NULL)
4254 {
4255 for (i = 0; i < colinfo->num_cols; i++)
4256 {
4257 char *colname = colinfo->colnames[i];
4258
4259 if (colname == NULL)
4260 continue;
4261
4262 /* Push down to left column, unless it's a system column */
4263 if (leftattnos[i] > 0)
4264 {
4265 expand_colnames_array_to(leftcolinfo, leftattnos[i]);
4266 leftcolinfo->colnames[leftattnos[i] - 1] = colname;
4267 }
4268
4269 /* Same on the righthand side */
4270 if (rightattnos[i] > 0)
4271 {
4272 expand_colnames_array_to(rightcolinfo, rightattnos[i]);
4273 rightcolinfo->colnames[rightattnos[i] - 1] = colname;
4274 }
4275 }
4276 }
4277
4278 /*
4279 * If there's a USING clause, select the USING column names and push
4280 * those names down to the children. We have two strategies:
4281 *
4282 * If dpns->unique_using is true, we force all USING names to be
4283 * unique across the whole query level. In principle we'd only need
4284 * the names of dangerous USING columns to be globally unique, but to
4285 * safely assign all USING names in a single pass, we have to enforce
4286 * the same uniqueness rule for all of them. However, if a USING
4287 * column's name has been pushed down from the parent, we should use
4288 * it as-is rather than making a uniqueness adjustment. This is
4289 * necessary when we're at an unnamed join, and it creates no risk of
4290 * ambiguity. Also, if there's a user-written output alias for a
4291 * merged column, we prefer to use that rather than the input name;
4292 * this simplifies the logic and seems likely to lead to less aliasing
4293 * overall.
4294 *
4295 * If dpns->unique_using is false, we only need USING names to be
4296 * unique within their own join RTE. We still need to honor
4297 * pushed-down names, though.
4298 *
4299 * Though significantly different in results, these two strategies are
4300 * implemented by the same code, with only the difference of whether
4301 * to put assigned names into dpns->using_names.
4302 */
4303 if (j->usingClause)
4304 {
4305 /* Copy the input parentUsing list so we don't modify it */
4306 parentUsing = list_copy(parentUsing);
4307
4308 /* USING names must correspond to the first join output columns */
4309 expand_colnames_array_to(colinfo, list_length(j->usingClause));
4310 i = 0;
4311 foreach(lc, j->usingClause)
4312 {
4313 char *colname = strVal(lfirst(lc));
4314
4315 /* Assert it's a merged column */
4316 Assert(leftattnos[i] != 0 && rightattnos[i] != 0);
4317
4318 /* Adopt passed-down name if any, else select unique name */
4319 if (colinfo->colnames[i] != NULL)
4320 colname = colinfo->colnames[i];
4321 else
4322 {
4323 /* Prefer user-written output alias if any */
4324 if (rte->alias && i < list_length(rte->alias->colnames))
4325 colname = strVal(list_nth(rte->alias->colnames, i));
4326 /* Make it appropriately unique */
4327 colname = make_colname_unique(colname, dpns, colinfo);
4328 if (dpns->unique_using)
4329 dpns->using_names = lappend(dpns->using_names,
4330 colname);
4331 /* Save it as output column name, too */
4332 colinfo->colnames[i] = colname;
4333 }
4334
4335 /* Remember selected names for use later */
4336 colinfo->usingNames = lappend(colinfo->usingNames, colname);
4337 parentUsing = lappend(parentUsing, colname);
4338
4339 /* Push down to left column, unless it's a system column */
4340 if (leftattnos[i] > 0)
4341 {
4342 expand_colnames_array_to(leftcolinfo, leftattnos[i]);
4343 leftcolinfo->colnames[leftattnos[i] - 1] = colname;
4344 }
4345
4346 /* Same on the righthand side */
4347 if (rightattnos[i] > 0)
4348 {
4349 expand_colnames_array_to(rightcolinfo, rightattnos[i]);
4350 rightcolinfo->colnames[rightattnos[i] - 1] = colname;
4351 }
4352
4353 i++;
4354 }
4355 }
4356
4357 /* Mark child deparse_columns structs with correct parentUsing info */
4358 leftcolinfo->parentUsing = parentUsing;
4359 rightcolinfo->parentUsing = parentUsing;
4360
4361 /* Now recursively assign USING column names in children */
4362 set_using_names(dpns, j->larg, parentUsing);
4363 set_using_names(dpns, j->rarg, parentUsing);
4364 }
4365 else
4366 elog(ERROR, "unrecognized node type: %d",
4367 (int) nodeTag(jtnode));
4368}
4369
4370/*
4371 * set_relation_column_names: select column aliases for a non-join RTE
4372 *
4373 * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
4374 * If any colnames entries are already filled in, those override local
4375 * choices.
4376 */
4377static void
4378set_relation_column_names(deparse_namespace *dpns, RangeTblEntry *rte,
4379 deparse_columns *colinfo)
4380{
4381 int ncolumns;
4382 char **real_colnames;
4383 bool changed_any;
4384 int noldcolumns;
4385 int i;
4386 int j;
4387
4388 /*
4389 * Construct an array of the current "real" column names of the RTE.
4390 * real_colnames[] will be indexed by physical column number, with NULL
4391 * entries for dropped columns.
4392 */
4393 if (rte->rtekind == RTE_RELATION)
4394 {
4395 /* Relation --- look to the system catalogs for up-to-date info */
4396 Relation rel;
4397 TupleDesc tupdesc;
4398
4399 rel = relation_open(rte->relid, AccessShareLock);
4400 tupdesc = RelationGetDescr(rel);
4401
4402 ncolumns = tupdesc->natts;
4403 real_colnames = (char **) palloc(ncolumns * sizeof(char *));
4404
4405 for (i = 0; i < ncolumns; i++)
4406 {
4407 Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
4408
4409 if (attr->attisdropped)
4410 real_colnames[i] = NULL;
4411 else
4412 real_colnames[i] = pstrdup(NameStr(attr->attname));
4413 }
4414 relation_close(rel, AccessShareLock);
4415 }
4416 else
4417 {
4418 /* Otherwise get the column names from eref or expandRTE() */
4419 List *colnames;
4420 ListCell *lc;
4421
4422 /*
4423 * Functions returning composites have the annoying property that some
4424 * of the composite type's columns might have been dropped since the
4425 * query was parsed. If possible, use expandRTE() to handle that
4426 * case, since it has the tedious logic needed to find out about
4427 * dropped columns. However, if we're explaining a plan, then we
4428 * don't have rte->functions because the planner thinks that won't be
4429 * needed later, and that breaks expandRTE(). So in that case we have
4430 * to rely on rte->eref, which may lead us to report a dropped
4431 * column's old name; that seems close enough for EXPLAIN's purposes.
4432 *
4433 * For non-RELATION, non-FUNCTION RTEs, we can just look at rte->eref,
4434 * which should be sufficiently up-to-date: no other RTE types can
4435 * have columns get dropped from under them after parsing.
4436 */
4437 if (rte->rtekind == RTE_FUNCTION && rte->functions != NIL)
4438 {
4439 /* Since we're not creating Vars, rtindex etc. don't matter */
4440 expandRTE(rte, 1, 0, VAR_RETURNING_DEFAULT, -1,
4441 true /* include dropped */ , &colnames, NULL);
4442 }
4443 else
4444 colnames = rte->eref->colnames;
4445
4446 ncolumns = list_length(colnames);
4447 real_colnames = (char **) palloc(ncolumns * sizeof(char *));
4448
4449 i = 0;
4450 foreach(lc, colnames)
4451 {
4452 /*
4453 * If the column name we find here is an empty string, then it's a
4454 * dropped column, so change to NULL.
4455 */
4456 char *cname = strVal(lfirst(lc));
4457
4458 if (cname[0] == '\0')
4459 cname = NULL;
4460 real_colnames[i] = cname;
4461 i++;
4462 }
4463 }
4464
4465 /*
4466 * Ensure colinfo->colnames has a slot for each column. (It could be long
4467 * enough already, if we pushed down a name for the last column.) Note:
4468 * it's possible that there are now more columns than there were when the
4469 * query was parsed, ie colnames could be longer than rte->eref->colnames.
4470 * We must assign unique aliases to the new columns too, else there could
4471 * be unresolved conflicts when the view/rule is reloaded.
4472 */
4473 expand_colnames_array_to(colinfo, ncolumns);
4474 Assert(colinfo->num_cols == ncolumns);
4475
4476 /*
4477 * Make sufficiently large new_colnames and is_new_col arrays, too.
4478 *
4479 * Note: because we leave colinfo->num_new_cols zero until after the loop,
4480 * colname_is_unique will not consult that array, which is fine because it
4481 * would only be duplicate effort.
4482 */
4483 colinfo->new_colnames = (char **) palloc(ncolumns * sizeof(char *));
4484 colinfo->is_new_col = (bool *) palloc(ncolumns * sizeof(bool));
4485
4486 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4487 build_colinfo_names_hash(colinfo);
4488
4489 /*
4490 * Scan the columns, select a unique alias for each one, and store it in
4491 * colinfo->colnames and colinfo->new_colnames. The former array has NULL
4492 * entries for dropped columns, the latter omits them. Also mark
4493 * new_colnames entries as to whether they are new since parse time; this
4494 * is the case for entries beyond the length of rte->eref->colnames.
4495 */
4496 noldcolumns = list_length(rte->eref->colnames);
4497 changed_any = false;
4498 j = 0;
4499 for (i = 0; i < ncolumns; i++)
4500 {
4501 char *real_colname = real_colnames[i];
4502 char *colname = colinfo->colnames[i];
4503
4504 /* Skip dropped columns */
4505 if (real_colname == NULL)
4506 {
4507 Assert(colname == NULL); /* colnames[i] is already NULL */
4508 continue;
4509 }
4510
4511 /* If alias already assigned, that's what to use */
4512 if (colname == NULL)
4513 {
4514 /* If user wrote an alias, prefer that over real column name */
4515 if (rte->alias && i < list_length(rte->alias->colnames))
4516 colname = strVal(list_nth(rte->alias->colnames, i));
4517 else
4518 colname = real_colname;
4519
4520 /* Unique-ify and insert into colinfo */
4521 colname = make_colname_unique(colname, dpns, colinfo);
4522
4523 colinfo->colnames[i] = colname;
4524 add_to_names_hash(colinfo, colname);
4525 }
4526
4527 /* Put names of non-dropped columns in new_colnames[] too */
4528 colinfo->new_colnames[j] = colname;
4529 /* And mark them as new or not */
4530 colinfo->is_new_col[j] = (i >= noldcolumns);
4531 j++;
4532
4533 /* Remember if any assigned aliases differ from "real" name */
4534 if (!changed_any && strcmp(colname, real_colname) != 0)
4535 changed_any = true;
4536 }
4537
4538 /* We're now done needing the colinfo's names_hash */
4539 destroy_colinfo_names_hash(colinfo);
4540
4541 /*
4542 * Set correct length for new_colnames[] array. (Note: if columns have
4543 * been added, colinfo->num_cols includes them, which is not really quite
4544 * right but is harmless, since any new columns must be at the end where
4545 * they won't affect varattnos of pre-existing columns.)
4546 */
4547 colinfo->num_new_cols = j;
4548
4549 /*
4550 * For a relation RTE, we need only print the alias column names if any
4551 * are different from the underlying "real" names. For a function RTE,
4552 * always emit a complete column alias list; this is to protect against
4553 * possible instability of the default column names (eg, from altering
4554 * parameter names). For tablefunc RTEs, we never print aliases, because
4555 * the column names are part of the clause itself. For other RTE types,
4556 * print if we changed anything OR if there were user-written column
4557 * aliases (since the latter would be part of the underlying "reality").
4558 */
4559 if (rte->rtekind == RTE_RELATION)
4560 colinfo->printaliases = changed_any;
4561 else if (rte->rtekind == RTE_FUNCTION)
4562 colinfo->printaliases = true;
4563 else if (rte->rtekind == RTE_TABLEFUNC)
4564 colinfo->printaliases = false;
4565 else if (rte->alias && rte->alias->colnames != NIL)
4566 colinfo->printaliases = true;
4567 else
4568 colinfo->printaliases = changed_any;
4569}
4570
4571/*
4572 * set_join_column_names: select column aliases for a join RTE
4573 *
4574 * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
4575 * If any colnames entries are already filled in, those override local
4576 * choices. Also, names for USING columns were already chosen by
4577 * set_using_names(). We further expect that column alias selection has been
4578 * completed for both input RTEs.
4579 */
4580static void
4581set_join_column_names(deparse_namespace *dpns, RangeTblEntry *rte,
4582 deparse_columns *colinfo)
4583{
4584 deparse_columns *leftcolinfo;
4585 deparse_columns *rightcolinfo;
4586 bool changed_any;
4587 int noldcolumns;
4588 int nnewcolumns;
4589 Bitmapset *leftmerged = NULL;
4590 Bitmapset *rightmerged = NULL;
4591 int i;
4592 int j;
4593 int ic;
4594 int jc;
4595
4596 /* Look up the previously-filled-in child deparse_columns structs */
4597 leftcolinfo = deparse_columns_fetch(colinfo->leftrti, dpns);
4598 rightcolinfo = deparse_columns_fetch(colinfo->rightrti, dpns);
4599
4600 /*
4601 * Ensure colinfo->colnames has a slot for each column. (It could be long
4602 * enough already, if we pushed down a name for the last column.) Note:
4603 * it's possible that one or both inputs now have more columns than there
4604 * were when the query was parsed, but we'll deal with that below. We
4605 * only need entries in colnames for pre-existing columns.
4606 */
4607 noldcolumns = list_length(rte->eref->colnames);
4608 expand_colnames_array_to(colinfo, noldcolumns);
4609 Assert(colinfo->num_cols == noldcolumns);
4610
4611 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4612 build_colinfo_names_hash(colinfo);
4613
4614 /*
4615 * Scan the join output columns, select an alias for each one, and store
4616 * it in colinfo->colnames. If there are USING columns, set_using_names()
4617 * already selected their names, so we can start the loop at the first
4618 * non-merged column.
4619 */
4620 changed_any = false;
4621 for (i = list_length(colinfo->usingNames); i < noldcolumns; i++)
4622 {
4623 char *colname = colinfo->colnames[i];
4624 char *real_colname;
4625
4626 /* Join column must refer to at least one input column */
4627 Assert(colinfo->leftattnos[i] != 0 || colinfo->rightattnos[i] != 0);
4628
4629 /* Get the child column name */
4630 if (colinfo->leftattnos[i] > 0)
4631 real_colname = leftcolinfo->colnames[colinfo->leftattnos[i] - 1];
4632 else if (colinfo->rightattnos[i] > 0)
4633 real_colname = rightcolinfo->colnames[colinfo->rightattnos[i] - 1];
4634 else
4635 {
4636 /* We're joining system columns --- use eref name */
4637 real_colname = strVal(list_nth(rte->eref->colnames, i));
4638 }
4639
4640 /* If child col has been dropped, no need to assign a join colname */
4641 if (real_colname == NULL)
4642 {
4643 colinfo->colnames[i] = NULL;
4644 continue;
4645 }
4646
4647 /* In an unnamed join, just report child column names as-is */
4648 if (rte->alias == NULL)
4649 {
4650 colinfo->colnames[i] = real_colname;
4651 add_to_names_hash(colinfo, real_colname);
4652 continue;
4653 }
4654
4655 /* If alias already assigned, that's what to use */
4656 if (colname == NULL)
4657 {
4658 /* If user wrote an alias, prefer that over real column name */
4659 if (rte->alias && i < list_length(rte->alias->colnames))
4660 colname = strVal(list_nth(rte->alias->colnames, i));
4661 else
4662 colname = real_colname;
4663
4664 /* Unique-ify and insert into colinfo */
4665 colname = make_colname_unique(colname, dpns, colinfo);
4666
4667 colinfo->colnames[i] = colname;
4668 add_to_names_hash(colinfo, colname);
4669 }
4670
4671 /* Remember if any assigned aliases differ from "real" name */
4672 if (!changed_any && strcmp(colname, real_colname) != 0)
4673 changed_any = true;
4674 }
4675
4676 /*
4677 * Calculate number of columns the join would have if it were re-parsed
4678 * now, and create storage for the new_colnames and is_new_col arrays.
4679 *
4680 * Note: colname_is_unique will be consulting new_colnames[] during the
4681 * loops below, so its not-yet-filled entries must be zeroes.
4682 */
4683 nnewcolumns = leftcolinfo->num_new_cols + rightcolinfo->num_new_cols -
4684 list_length(colinfo->usingNames);
4685 colinfo->num_new_cols = nnewcolumns;
4686 colinfo->new_colnames = (char **) palloc0(nnewcolumns * sizeof(char *));
4687 colinfo->is_new_col = (bool *) palloc0(nnewcolumns * sizeof(bool));
4688
4689 /*
4690 * Generating the new_colnames array is a bit tricky since any new columns
4691 * added since parse time must be inserted in the right places. This code
4692 * must match the parser, which will order a join's columns as merged
4693 * columns first (in USING-clause order), then non-merged columns from the
4694 * left input (in attnum order), then non-merged columns from the right
4695 * input (ditto). If one of the inputs is itself a join, its columns will
4696 * be ordered according to the same rule, which means newly-added columns
4697 * might not be at the end. We can figure out what's what by consulting
4698 * the leftattnos and rightattnos arrays plus the input is_new_col arrays.
4699 *
4700 * In these loops, i indexes leftattnos/rightattnos (so it's join varattno
4701 * less one), j indexes new_colnames/is_new_col, and ic/jc have similar
4702 * meanings for the current child RTE.
4703 */
4704
4705 /* Handle merged columns; they are first and can't be new */
4706 i = j = 0;
4707 while (i < noldcolumns &&
4708 colinfo->leftattnos[i] != 0 &&
4709 colinfo->rightattnos[i] != 0)
4710 {
4711 /* column name is already determined and known unique */
4712 colinfo->new_colnames[j] = colinfo->colnames[i];
4713 colinfo->is_new_col[j] = false;
4714
4715 /* build bitmapsets of child attnums of merged columns */
4716 if (colinfo->leftattnos[i] > 0)
4717 leftmerged = bms_add_member(leftmerged, colinfo->leftattnos[i]);
4718 if (colinfo->rightattnos[i] > 0)
4719 rightmerged = bms_add_member(rightmerged, colinfo->rightattnos[i]);
4720
4721 i++, j++;
4722 }
4723
4724 /* Handle non-merged left-child columns */
4725 ic = 0;
4726 for (jc = 0; jc < leftcolinfo->num_new_cols; jc++)
4727 {
4728 char *child_colname = leftcolinfo->new_colnames[jc];
4729
4730 if (!leftcolinfo->is_new_col[jc])
4731 {
4732 /* Advance ic to next non-dropped old column of left child */
4733 while (ic < leftcolinfo->num_cols &&
4734 leftcolinfo->colnames[ic] == NULL)
4735 ic++;
4736 Assert(ic < leftcolinfo->num_cols);
4737 ic++;
4738 /* If it is a merged column, we already processed it */
4739 if (bms_is_member(ic, leftmerged))
4740 continue;
4741 /* Else, advance i to the corresponding existing join column */
4742 while (i < colinfo->num_cols &&
4743 colinfo->colnames[i] == NULL)
4744 i++;
4745 Assert(i < colinfo->num_cols);
4746 Assert(ic == colinfo->leftattnos[i]);
4747 /* Use the already-assigned name of this column */
4748 colinfo->new_colnames[j] = colinfo->colnames[i];
4749 i++;
4750 }
4751 else
4752 {
4753 /*
4754 * Unique-ify the new child column name and assign, unless we're
4755 * in an unnamed join, in which case just copy
4756 */
4757 if (rte->alias != NULL)
4758 {
4759 colinfo->new_colnames[j] =
4760 make_colname_unique(child_colname, dpns, colinfo);
4761 if (!changed_any &&
4762 strcmp(colinfo->new_colnames[j], child_colname) != 0)
4763 changed_any = true;
4764 }
4765 else
4766 colinfo->new_colnames[j] = child_colname;
4767 add_to_names_hash(colinfo, colinfo->new_colnames[j]);
4768 }
4769
4770 colinfo->is_new_col[j] = leftcolinfo->is_new_col[jc];
4771 j++;
4772 }
4773
4774 /* Handle non-merged right-child columns in exactly the same way */
4775 ic = 0;
4776 for (jc = 0; jc < rightcolinfo->num_new_cols; jc++)
4777 {
4778 char *child_colname = rightcolinfo->new_colnames[jc];
4779
4780 if (!rightcolinfo->is_new_col[jc])
4781 {
4782 /* Advance ic to next non-dropped old column of right child */
4783 while (ic < rightcolinfo->num_cols &&
4784 rightcolinfo->colnames[ic] == NULL)
4785 ic++;
4786 Assert(ic < rightcolinfo->num_cols);
4787 ic++;
4788 /* If it is a merged column, we already processed it */
4789 if (bms_is_member(ic, rightmerged))
4790 continue;
4791 /* Else, advance i to the corresponding existing join column */
4792 while (i < colinfo->num_cols &&
4793 colinfo->colnames[i] == NULL)
4794 i++;
4795 Assert(i < colinfo->num_cols);
4796 Assert(ic == colinfo->rightattnos[i]);
4797 /* Use the already-assigned name of this column */
4798 colinfo->new_colnames[j] = colinfo->colnames[i];
4799 i++;
4800 }
4801 else
4802 {
4803 /*
4804 * Unique-ify the new child column name and assign, unless we're
4805 * in an unnamed join, in which case just copy
4806 */
4807 if (rte->alias != NULL)
4808 {
4809 colinfo->new_colnames[j] =
4810 make_colname_unique(child_colname, dpns, colinfo);
4811 if (!changed_any &&
4812 strcmp(colinfo->new_colnames[j], child_colname) != 0)
4813 changed_any = true;
4814 }
4815 else
4816 colinfo->new_colnames[j] = child_colname;
4817 add_to_names_hash(colinfo, colinfo->new_colnames[j]);
4818 }
4819
4820 colinfo->is_new_col[j] = rightcolinfo->is_new_col[jc];
4821 j++;
4822 }
4823
4824 /* Assert we processed the right number of columns */
4825#ifdef USE_ASSERT_CHECKING
4826 while (i < colinfo->num_cols && colinfo->colnames[i] == NULL)
4827 i++;
4828 Assert(i == colinfo->num_cols);
4829 Assert(j == nnewcolumns);
4830#endif
4831
4832 /* We're now done needing the colinfo's names_hash */
4833 destroy_colinfo_names_hash(colinfo);
4834
4835 /*
4836 * For a named join, print column aliases if we changed any from the child
4837 * names. Unnamed joins cannot print aliases.
4838 */
4839 if (rte->alias != NULL)
4840 colinfo->printaliases = changed_any;
4841 else
4842 colinfo->printaliases = false;
4843}
4844
4845/*
4846 * colname_is_unique: is colname distinct from already-chosen column names?
4847 *
4848 * dpns is query-wide info, colinfo is for the column's RTE
4849 */
4850static bool
4851colname_is_unique(const char *colname, deparse_namespace *dpns,
4852 deparse_columns *colinfo)
4853{
4854 int i;
4855 ListCell *lc;
4856
4857 /*
4858 * If we have a hash table, consult that instead of linearly scanning the
4859 * colinfo's strings.
4860 */
4861 if (colinfo->names_hash)
4862 {
4863 if (hash_search(colinfo->names_hash,
4864 colname,
4865 HASH_FIND,
4866 NULL) != NULL)
4867 return false;
4868 }
4869 else
4870 {
4871 /* Check against already-assigned column aliases within RTE */
4872 for (i = 0; i < colinfo->num_cols; i++)
4873 {
4874 char *oldname = colinfo->colnames[i];
4875
4876 if (oldname && strcmp(oldname, colname) == 0)
4877 return false;
4878 }
4879
4880 /*
4881 * If we're building a new_colnames array, check that too (this will
4882 * be partially but not completely redundant with the previous checks)
4883 */
4884 for (i = 0; i < colinfo->num_new_cols; i++)
4885 {
4886 char *oldname = colinfo->new_colnames[i];
4887
4888 if (oldname && strcmp(oldname, colname) == 0)
4889 return false;
4890 }
4891
4892 /*
4893 * Also check against names already assigned for parent-join USING
4894 * cols
4895 */
4896 foreach(lc, colinfo->parentUsing)
4897 {
4898 char *oldname = (char *) lfirst(lc);
4899
4900 if (strcmp(oldname, colname) == 0)
4901 return false;
4902 }
4903 }
4904
4905 /*
4906 * Also check against USING-column names that must be globally unique.
4907 * These are not hashed, but there should be few of them.
4908 */
4909 foreach(lc, dpns->using_names)
4910 {
4911 char *oldname = (char *) lfirst(lc);
4912
4913 if (strcmp(oldname, colname) == 0)
4914 return false;
4915 }
4916
4917 return true;
4918}
4919
4920/*
4921 * make_colname_unique: modify colname if necessary to make it unique
4922 *
4923 * dpns is query-wide info, colinfo is for the column's RTE
4924 */
4925static char *
4926make_colname_unique(char *colname, deparse_namespace *dpns,
4927 deparse_columns *colinfo)
4928{
4929 /*
4930 * If the selected name isn't unique, append digits to make it so. For a
4931 * very long input name, we might have to truncate to stay within
4932 * NAMEDATALEN.
4933 */
4934 if (!colname_is_unique(colname, dpns, colinfo))
4935 {
4936 int colnamelen = strlen(colname);
4937 char *modname = (char *) palloc(colnamelen + 16);
4938 int i = 0;
4939
4940 do
4941 {
4942 i++;
4943 for (;;)
4944 {
4945 memcpy(modname, colname, colnamelen);
4946 sprintf(modname + colnamelen, "_%d", i);
4947 if (strlen(modname) < NAMEDATALEN)
4948 break;
4949 /* drop chars from colname to keep all the digits */
4950 colnamelen = pg_mbcliplen(colname, colnamelen,
4951 colnamelen - 1);
4952 }
4953 } while (!colname_is_unique(modname, dpns, colinfo));
4954 colname = modname;
4955 }
4956 return colname;
4957}
4958
4959/*
4960 * expand_colnames_array_to: make colinfo->colnames at least n items long
4961 *
4962 * Any added array entries are initialized to zero.
4963 */
4964static void
4965expand_colnames_array_to(deparse_columns *colinfo, int n)
4966{
4967 if (n > colinfo->num_cols)
4968 {
4969 if (colinfo->colnames == NULL)
4970 colinfo->colnames = palloc0_array(char *, n);
4971 else
4972 colinfo->colnames = repalloc0_array(colinfo->colnames, char *, colinfo->num_cols, n);
4973 colinfo->num_cols = n;
4974 }
4975}
4976
4977/*
4978 * build_colinfo_names_hash: optionally construct a hash table for colinfo
4979 */
4980static void
4981build_colinfo_names_hash(deparse_columns *colinfo)
4982{
4983 HASHCTL hash_ctl;
4984 int i;
4985 ListCell *lc;
4986
4987 /*
4988 * Use a hash table only for RTEs with at least 32 columns. (The cutoff
4989 * is somewhat arbitrary, but let's choose it so that this code does get
4990 * exercised in the regression tests.)
4991 */
4992 if (colinfo->num_cols < 32)
4993 return;
4994
4995 /*
4996 * Set up the hash table. The entries are just strings with no other
4997 * payload.
4998 */
4999 hash_ctl.keysize = NAMEDATALEN;
5000 hash_ctl.entrysize = NAMEDATALEN;
5001 hash_ctl.hcxt = CurrentMemoryContext;
5002 colinfo->names_hash = hash_create("deparse_columns names",
5003 colinfo->num_cols + colinfo->num_new_cols,
5004 &hash_ctl,
5005 HASH_ELEM | HASH_STRINGS | HASH_CONTEXT);
5006
5007 /*
5008 * Preload the hash table with any names already present (these would have
5009 * come from set_using_names).
5010 */
5011 for (i = 0; i < colinfo->num_cols; i++)
5012 {
5013 char *oldname = colinfo->colnames[i];
5014
5015 if (oldname)
5016 add_to_names_hash(colinfo, oldname);
5017 }
5018
5019 for (i = 0; i < colinfo->num_new_cols; i++)
5020 {
5021 char *oldname = colinfo->new_colnames[i];
5022
5023 if (oldname)
5024 add_to_names_hash(colinfo, oldname);
5025 }
5026
5027 foreach(lc, colinfo->parentUsing)
5028 {
5029 char *oldname = (char *) lfirst(lc);
5030
5031 add_to_names_hash(colinfo, oldname);
5032 }
5033}
5034
5035/*
5036 * add_to_names_hash: add a string to the names_hash, if we're using one
5037 */
5038static void
5039add_to_names_hash(deparse_columns *colinfo, const char *name)
5040{
5041 if (colinfo->names_hash)
5042 (void) hash_search(colinfo->names_hash,
5043 name,
5044 HASH_ENTER,
5045 NULL);
5046}
5047
5048/*
5049 * destroy_colinfo_names_hash: destroy hash table when done with it
5050 */
5051static void
5052destroy_colinfo_names_hash(deparse_columns *colinfo)
5053{
5054 if (colinfo->names_hash)
5055 {
5056 hash_destroy(colinfo->names_hash);
5057 colinfo->names_hash = NULL;
5058 }
5059}
5060
5061/*
5062 * identify_join_columns: figure out where columns of a join come from
5063 *
5064 * Fills the join-specific fields of the colinfo struct, except for
5065 * usingNames which is filled later.
5066 */
5067static void
5068identify_join_columns(JoinExpr *j, RangeTblEntry *jrte,
5069 deparse_columns *colinfo)
5070{
5071 int numjoincols;
5072 int jcolno;
5073 int rcolno;
5074 ListCell *lc;
5075
5076 /* Extract left/right child RT indexes */
5077 if (IsA(j->larg, RangeTblRef))
5078 colinfo->leftrti = ((RangeTblRef *) j->larg)->rtindex;
5079 else if (IsA(j->larg, JoinExpr))
5080 colinfo->leftrti = ((JoinExpr *) j->larg)->rtindex;
5081 else
5082 elog(ERROR, "unrecognized node type in jointree: %d",
5083 (int) nodeTag(j->larg));
5084 if (IsA(j->rarg, RangeTblRef))
5085 colinfo->rightrti = ((RangeTblRef *) j->rarg)->rtindex;
5086 else if (IsA(j->rarg, JoinExpr))
5087 colinfo->rightrti = ((JoinExpr *) j->rarg)->rtindex;
5088 else
5089 elog(ERROR, "unrecognized node type in jointree: %d",
5090 (int) nodeTag(j->rarg));
5091
5092 /* Assert children will be processed earlier than join in second pass */
5093 Assert(colinfo->leftrti < j->rtindex);
5094 Assert(colinfo->rightrti < j->rtindex);
5095
5096 /* Initialize result arrays with zeroes */
5097 numjoincols = list_length(jrte->joinaliasvars);
5098 Assert(numjoincols == list_length(jrte->eref->colnames));
5099 colinfo->leftattnos = (int *) palloc0(numjoincols * sizeof(int));
5100 colinfo->rightattnos = (int *) palloc0(numjoincols * sizeof(int));
5101
5102 /*
5103 * Deconstruct RTE's joinleftcols/joinrightcols into desired format.
5104 * Recall that the column(s) merged due to USING are the first column(s)
5105 * of the join output. We need not do anything special while scanning
5106 * joinleftcols, but while scanning joinrightcols we must distinguish
5107 * merged from unmerged columns.
5108 */
5109 jcolno = 0;
5110 foreach(lc, jrte->joinleftcols)
5111 {
5112 int leftattno = lfirst_int(lc);
5113
5114 colinfo->leftattnos[jcolno++] = leftattno;
5115 }
5116 rcolno = 0;
5117 foreach(lc, jrte->joinrightcols)
5118 {
5119 int rightattno = lfirst_int(lc);
5120
5121 if (rcolno < jrte->joinmergedcols) /* merged column? */
5122 colinfo->rightattnos[rcolno] = rightattno;
5123 else
5124 colinfo->rightattnos[jcolno++] = rightattno;
5125 rcolno++;
5126 }
5127 Assert(jcolno == numjoincols);
5128}
5129
5130/*
5131 * get_rtable_name: convenience function to get a previously assigned RTE alias
5132 *
5133 * The RTE must belong to the topmost namespace level in "context".
5134 */
5135static char *
5136get_rtable_name(int rtindex, deparse_context *context)
5137{
5138 deparse_namespace *dpns = (deparse_namespace *) linitial(context->namespaces);
5139
5140 Assert(rtindex > 0 && rtindex <= list_length(dpns->rtable_names));
5141 return (char *) list_nth(dpns->rtable_names, rtindex - 1);
5142}
5143
5144/*
5145 * set_deparse_plan: set up deparse_namespace to parse subexpressions
5146 * of a given Plan node
5147 *
5148 * This sets the plan, outer_plan, inner_plan, outer_tlist, inner_tlist,
5149 * and index_tlist fields. Caller must already have adjusted the ancestors
5150 * list if necessary. Note that the rtable, subplans, and ctes fields do
5151 * not need to change when shifting attention to different plan nodes in a
5152 * single plan tree.
5153 */
5154static void
5155set_deparse_plan(deparse_namespace *dpns, Plan *plan)
5156{
5157 dpns->plan = plan;
5158
5159 /*
5160 * We special-case Append and MergeAppend to pretend that the first child
5161 * plan is the OUTER referent; we have to interpret OUTER Vars in their
5162 * tlists according to one of the children, and the first one is the most
5163 * natural choice.
5164 */
5165 if (IsA(plan, Append))
5166 dpns->outer_plan = linitial(((Append *) plan)->appendplans);
5167 else if (IsA(plan, MergeAppend))
5168 dpns->outer_plan = linitial(((MergeAppend *) plan)->mergeplans);
5169 else
5170 dpns->outer_plan = outerPlan(plan);
5171
5172 if (dpns->outer_plan)
5173 dpns->outer_tlist = dpns->outer_plan->targetlist;
5174 else
5175 dpns->outer_tlist = NIL;
5176
5177 /*
5178 * For a SubqueryScan, pretend the subplan is INNER referent. (We don't
5179 * use OUTER because that could someday conflict with the normal meaning.)
5180 * Likewise, for a CteScan, pretend the subquery's plan is INNER referent.
5181 * For a WorkTableScan, locate the parent RecursiveUnion plan node and use
5182 * that as INNER referent.
5183 *
5184 * For MERGE, pretend the ModifyTable's source plan (its outer plan) is
5185 * INNER referent. This is the join from the target relation to the data
5186 * source, and all INNER_VAR Vars in other parts of the query refer to its
5187 * targetlist.
5188 *
5189 * For ON CONFLICT .. UPDATE we just need the inner tlist to point to the
5190 * excluded expression's tlist. (Similar to the SubqueryScan we don't want
5191 * to reuse OUTER, it's used for RETURNING in some modify table cases,
5192 * although not INSERT .. CONFLICT).
5193 */
5194 if (IsA(plan, SubqueryScan))
5195 dpns->inner_plan = ((SubqueryScan *) plan)->subplan;
5196 else if (IsA(plan, CteScan))
5197 dpns->inner_plan = list_nth(dpns->subplans,
5198 ((CteScan *) plan)->ctePlanId - 1);
5199 else if (IsA(plan, WorkTableScan))
5200 dpns->inner_plan = find_recursive_union(dpns,
5201 (WorkTableScan *) plan);
5202 else if (IsA(plan, ModifyTable))
5203 {
5204 if (((ModifyTable *) plan)->operation == CMD_MERGE)
5205 dpns->inner_plan = outerPlan(plan);
5206 else
5207 dpns->inner_plan = plan;
5208 }
5209 else
5210 dpns->inner_plan = innerPlan(plan);
5211
5212 if (IsA(plan, ModifyTable) && ((ModifyTable *) plan)->operation == CMD_INSERT)
5213 dpns->inner_tlist = ((ModifyTable *) plan)->exclRelTlist;
5214 else if (dpns->inner_plan)
5215 dpns->inner_tlist = dpns->inner_plan->targetlist;
5216 else
5217 dpns->inner_tlist = NIL;
5218
5219 /* Set up referent for INDEX_VAR Vars, if needed */
5220 if (IsA(plan, IndexOnlyScan))
5221 dpns->index_tlist = ((IndexOnlyScan *) plan)->indextlist;
5222 else if (IsA(plan, ForeignScan))
5223 dpns->index_tlist = ((ForeignScan *) plan)->fdw_scan_tlist;
5224 else if (IsA(plan, CustomScan))
5225 dpns->index_tlist = ((CustomScan *) plan)->custom_scan_tlist;
5226 else
5227 dpns->index_tlist = NIL;
5228}
5229
5230/*
5231 * Locate the ancestor plan node that is the RecursiveUnion generating
5232 * the WorkTableScan's work table. We can match on wtParam, since that
5233 * should be unique within the plan tree.
5234 */
5235static Plan *
5236find_recursive_union(deparse_namespace *dpns, WorkTableScan *wtscan)
5237{
5238 ListCell *lc;
5239
5240 foreach(lc, dpns->ancestors)
5241 {
5242 Plan *ancestor = (Plan *) lfirst(lc);
5243
5244 if (IsA(ancestor, RecursiveUnion) &&
5245 ((RecursiveUnion *) ancestor)->wtParam == wtscan->wtParam)
5246 return ancestor;
5247 }
5248 elog(ERROR, "could not find RecursiveUnion for WorkTableScan with wtParam %d",
5249 wtscan->wtParam);
5250 return NULL;
5251}
5252
5253/*
5254 * push_child_plan: temporarily transfer deparsing attention to a child plan
5255 *
5256 * When expanding an OUTER_VAR or INNER_VAR reference, we must adjust the
5257 * deparse context in case the referenced expression itself uses
5258 * OUTER_VAR/INNER_VAR. We modify the top stack entry in-place to avoid
5259 * affecting levelsup issues (although in a Plan tree there really shouldn't
5260 * be any).
5261 *
5262 * Caller must provide a local deparse_namespace variable to save the
5263 * previous state for pop_child_plan.
5264 */
5265static void
5266push_child_plan(deparse_namespace *dpns, Plan *plan,
5267 deparse_namespace *save_dpns)
5268{
5269 /* Save state for restoration later */
5270 *save_dpns = *dpns;
5271
5272 /* Link current plan node into ancestors list */
5273 dpns->ancestors = lcons(dpns->plan, dpns->ancestors);
5274
5275 /* Set attention on selected child */
5276 set_deparse_plan(dpns, plan);
5277}
5278
5279/*
5280 * pop_child_plan: undo the effects of push_child_plan
5281 */
5282static void
5283pop_child_plan(deparse_namespace *dpns, deparse_namespace *save_dpns)
5284{
5285 List *ancestors;
5286
5287 /* Get rid of ancestors list cell added by push_child_plan */
5288 ancestors = list_delete_first(dpns->ancestors);
5289
5290 /* Restore fields changed by push_child_plan */
5291 *dpns = *save_dpns;
5292
5293 /* Make sure dpns->ancestors is right (may be unnecessary) */
5294 dpns->ancestors = ancestors;
5295}
5296
5297/*
5298 * push_ancestor_plan: temporarily transfer deparsing attention to an
5299 * ancestor plan
5300 *
5301 * When expanding a Param reference, we must adjust the deparse context
5302 * to match the plan node that contains the expression being printed;
5303 * otherwise we'd fail if that expression itself contains a Param or
5304 * OUTER_VAR/INNER_VAR/INDEX_VAR variable.
5305 *
5306 * The target ancestor is conveniently identified by the ListCell holding it
5307 * in dpns->ancestors.
5308 *
5309 * Caller must provide a local deparse_namespace variable to save the
5310 * previous state for pop_ancestor_plan.
5311 */
5312static void
5313push_ancestor_plan(deparse_namespace *dpns, ListCell *ancestor_cell,
5314 deparse_namespace *save_dpns)
5315{
5316 Plan *plan = (Plan *) lfirst(ancestor_cell);
5317
5318 /* Save state for restoration later */
5319 *save_dpns = *dpns;
5320
5321 /* Build a new ancestor list with just this node's ancestors */
5322 dpns->ancestors =
5323 list_copy_tail(dpns->ancestors,
5324 list_cell_number(dpns->ancestors, ancestor_cell) + 1);
5325
5326 /* Set attention on selected ancestor */
5327 set_deparse_plan(dpns, plan);
5328}
5329
5330/*
5331 * pop_ancestor_plan: undo the effects of push_ancestor_plan
5332 */
5333static void
5334pop_ancestor_plan(deparse_namespace *dpns, deparse_namespace *save_dpns)
5335{
5336 /* Free the ancestor list made in push_ancestor_plan */
5337 list_free(dpns->ancestors);
5338
5339 /* Restore fields changed by push_ancestor_plan */
5340 *dpns = *save_dpns;
5341}
5342
5343
5344/* ----------
5345 * make_ruledef - reconstruct the CREATE RULE command
5346 * for a given pg_rewrite tuple
5347 * ----------
5348 */
5349static void
5350make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,
5351 int prettyFlags)
5352{
5353 char *rulename;
5354 char ev_type;
5355 Oid ev_class;
5356 bool is_instead;
5357 char *ev_qual;
5358 char *ev_action;
5359 List *actions;
5360 Relation ev_relation;
5361 TupleDesc viewResultDesc = NULL;
5362 int fno;
5363 Datum dat;
5364 bool isnull;
5365
5366 /*
5367 * Get the attribute values from the rules tuple
5368 */
5369 fno = SPI_fnumber(rulettc, "rulename");
5370 dat = SPI_getbinval(ruletup, rulettc, fno, &isnull);
5371 Assert(!isnull);
5372 rulename = NameStr(*(DatumGetName(dat)));
5373
5374 fno = SPI_fnumber(rulettc, "ev_type");
5375 dat = SPI_getbinval(ruletup, rulettc, fno, &isnull);
5376 Assert(!isnull);
5377 ev_type = DatumGetChar(dat);
5378
5379 fno = SPI_fnumber(rulettc, "ev_class");
5380 dat = SPI_getbinval(ruletup, rulettc, fno, &isnull);
5381 Assert(!isnull);
5382 ev_class = DatumGetObjectId(dat);
5383
5384 fno = SPI_fnumber(rulettc, "is_instead");
5385 dat = SPI_getbinval(ruletup, rulettc, fno, &isnull);
5386 Assert(!isnull);
5387 is_instead = DatumGetBool(dat);
5388
5389 fno = SPI_fnumber(rulettc, "ev_qual");
5390 ev_qual = SPI_getvalue(ruletup, rulettc, fno);
5391 Assert(ev_qual != NULL);
5392
5393 fno = SPI_fnumber(rulettc, "ev_action");
5394 ev_action = SPI_getvalue(ruletup, rulettc, fno);
5395 Assert(ev_action != NULL);
5396 actions = (List *) stringToNode(ev_action);
5397 if (actions == NIL)
5398 elog(ERROR, "invalid empty ev_action list");
5399
5400 ev_relation = table_open(ev_class, AccessShareLock);
5401
5402 /*
5403 * Build the rules definition text
5404 */
5405 appendStringInfo(buf, "CREATE RULE %s AS",
5406 quote_identifier(rulename));
5407
5408 if (prettyFlags & PRETTYFLAG_INDENT)
5409 appendStringInfoString(buf, "\n ON ");
5410 else
5411 appendStringInfoString(buf, " ON ");
5412
5413 /* The event the rule is fired for */
5414 switch (ev_type)
5415 {
5416 case '1':
5417 appendStringInfoString(buf, "SELECT");
5418 viewResultDesc = RelationGetDescr(ev_relation);
5419 break;
5420
5421 case '2':
5422 appendStringInfoString(buf, "UPDATE");
5423 break;
5424
5425 case '3':
5426 appendStringInfoString(buf, "INSERT");
5427 break;
5428
5429 case '4':
5430 appendStringInfoString(buf, "DELETE");
5431 break;
5432
5433 default:
5434 ereport(ERROR,
5435 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
5436 errmsg("rule \"%s\" has unsupported event type %d",
5437 rulename, ev_type)));
5438 break;
5439 }
5440
5441 /* The relation the rule is fired on */
5442 appendStringInfo(buf, " TO %s",
5443 (prettyFlags & PRETTYFLAG_SCHEMA) ?
5444 generate_relation_name(ev_class, NIL) :
5445 generate_qualified_relation_name(ev_class));
5446
5447 /* If the rule has an event qualification, add it */
5448 if (strcmp(ev_qual, "<>") != 0)
5449 {
5450 Node *qual;
5451 Query *query;
5452 deparse_context context;
5453 deparse_namespace dpns;
5454
5455 if (prettyFlags & PRETTYFLAG_INDENT)
5456 appendStringInfoString(buf, "\n ");
5457 appendStringInfoString(buf, " WHERE ");
5458
5459 qual = stringToNode(ev_qual);
5460
5461 /*
5462 * We need to make a context for recognizing any Vars in the qual
5463 * (which can only be references to OLD and NEW). Use the rtable of
5464 * the first query in the action list for this purpose.
5465 */
5466 query = (Query *) linitial(actions);
5467
5468 /*
5469 * If the action is INSERT...SELECT, OLD/NEW have been pushed down
5470 * into the SELECT, and that's what we need to look at. (Ugly kluge
5471 * ... try to fix this when we redesign querytrees.)
5472 */
5473 query = getInsertSelectQuery(query, NULL);
5474
5475 /* Must acquire locks right away; see notes in get_query_def() */
5476 AcquireRewriteLocks(query, false, false);
5477
5478 context.buf = buf;
5479 context.namespaces = list_make1(&dpns);
5480 context.resultDesc = NULL;
5481 context.targetList = NIL;
5482 context.windowClause = NIL;
5483 context.varprefix = (list_length(query->rtable) != 1);
5484 context.prettyFlags = prettyFlags;
5485 context.wrapColumn = WRAP_COLUMN_DEFAULT;
5486 context.indentLevel = PRETTYINDENT_STD;
5487 context.colNamesVisible = true;
5488 context.inGroupBy = false;
5489 context.varInOrderBy = false;
5490 context.appendparents = NULL;
5491
5492 set_deparse_for_query(&dpns, query, NIL);
5493
5494 get_rule_expr(qual, &context, false);
5495 }
5496
5497 appendStringInfoString(buf, " DO ");
5498
5499 /* The INSTEAD keyword (if so) */
5500 if (is_instead)
5501 appendStringInfoString(buf, "INSTEAD ");
5502
5503 /* Finally the rules actions */
5504 if (list_length(actions) > 1)
5505 {
5506 ListCell *action;
5507 Query *query;
5508
5509 appendStringInfoChar(buf, '(');
5510 foreach(action, actions)
5511 {
5512 query = (Query *) lfirst(action);
5513 get_query_def(query, buf, NIL, viewResultDesc, true,
5514 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
5515 if (prettyFlags)
5516 appendStringInfoString(buf, ";\n");
5517 else
5518 appendStringInfoString(buf, "; ");
5519 }
5520 appendStringInfoString(buf, ");");
5521 }
5522 else
5523 {
5524 Query *query;
5525
5526 query = (Query *) linitial(actions);
5527 get_query_def(query, buf, NIL, viewResultDesc, true,
5528 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
5529 appendStringInfoChar(buf, ';');
5530 }
5531
5532 table_close(ev_relation, AccessShareLock);
5533}
5534
5535
5536/* ----------
5537 * make_viewdef - reconstruct the SELECT part of a
5538 * view rewrite rule
5539 * ----------
5540 */
5541static void
5542make_viewdef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,
5543 int prettyFlags, int wrapColumn)
5544{
5545 Query *query;
5546 char ev_type;
5547 Oid ev_class;
5548 bool is_instead;
5549 char *ev_qual;
5550 char *ev_action;
5551 List *actions;
5552 Relation ev_relation;
5553 int fno;
5554 Datum dat;
5555 bool isnull;
5556
5557 /*
5558 * Get the attribute values from the rules tuple
5559 */
5560 fno = SPI_fnumber(rulettc, "ev_type");
5561 dat = SPI_getbinval(ruletup, rulettc, fno, &isnull);
5562 Assert(!isnull);
5563 ev_type = DatumGetChar(dat);
5564
5565 fno = SPI_fnumber(rulettc, "ev_class");
5566 dat = SPI_getbinval(ruletup, rulettc, fno, &isnull);
5567 Assert(!isnull);
5568 ev_class = DatumGetObjectId(dat);
5569
5570 fno = SPI_fnumber(rulettc, "is_instead");
5571 dat = SPI_getbinval(ruletup, rulettc, fno, &isnull);
5572 Assert(!isnull);
5573 is_instead = DatumGetBool(dat);
5574
5575 fno = SPI_fnumber(rulettc, "ev_qual");
5576 ev_qual = SPI_getvalue(ruletup, rulettc, fno);
5577 Assert(ev_qual != NULL);
5578
5579 fno = SPI_fnumber(rulettc, "ev_action");
5580 ev_action = SPI_getvalue(ruletup, rulettc, fno);
5581 Assert(ev_action != NULL);
5582 actions = (List *) stringToNode(ev_action);
5583
5584 if (list_length(actions) != 1)
5585 {
5586 /* keep output buffer empty and leave */
5587 return;
5588 }
5589
5590 query = (Query *) linitial(actions);
5591
5592 if (ev_type != '1' || !is_instead ||
5593 strcmp(ev_qual, "<>") != 0 || query->commandType != CMD_SELECT)
5594 {
5595 /* keep output buffer empty and leave */
5596 return;
5597 }
5598
5599 ev_relation = table_open(ev_class, AccessShareLock);
5600
5601 get_query_def(query, buf, NIL, RelationGetDescr(ev_relation), true,
5602 prettyFlags, wrapColumn, 0);
5603 appendStringInfoChar(buf, ';');
5604
5605 table_close(ev_relation, AccessShareLock);
5606}
5607
5608
5609/* ----------
5610 * get_query_def - Parse back one query parsetree
5611 *
5612 * query: parsetree to be displayed
5613 * buf: output text is appended to buf
5614 * parentnamespace: list (initially empty) of outer-level deparse_namespace's
5615 * resultDesc: if not NULL, the output tuple descriptor for the view
5616 * represented by a SELECT query. We use the column names from it
5617 * to label SELECT output columns, in preference to names in the query
5618 * colNamesVisible: true if the surrounding context cares about the output
5619 * column names at all (as, for example, an EXISTS() context does not);
5620 * when false, we can suppress dummy column labels such as "?column?"
5621 * prettyFlags: bitmask of PRETTYFLAG_XXX options
5622 * wrapColumn: maximum line length, or -1 to disable wrapping
5623 * startIndent: initial indentation amount
5624 * ----------
5625 */
5626static void
5627get_query_def(Query *query, StringInfo buf, List *parentnamespace,
5628 TupleDesc resultDesc, bool colNamesVisible,
5629 int prettyFlags, int wrapColumn, int startIndent)
5630{
5631 deparse_context context;
5632 deparse_namespace dpns;
5633 int rtable_size;
5634
5635 /* Guard against excessively long or deeply-nested queries */
5636 CHECK_FOR_INTERRUPTS();
5637 check_stack_depth();
5638
5639 rtable_size = query->hasGroupRTE ?
5640 list_length(query->rtable) - 1 :
5641 list_length(query->rtable);
5642
5643 /*
5644 * Replace any Vars in the query's targetlist and havingQual that
5645 * reference GROUP outputs with the underlying grouping expressions.
5646 */
5647 if (query->hasGroupRTE)
5648 {
5649 query->targetList = (List *)
5650 flatten_group_exprs(NULL, query, (Node *) query->targetList);
5651 query->havingQual =
5652 flatten_group_exprs(NULL, query, query->havingQual);
5653 }
5654
5655 /*
5656 * Before we begin to examine the query, acquire locks on referenced
5657 * relations, and fix up deleted columns in JOIN RTEs. This ensures
5658 * consistent results. Note we assume it's OK to scribble on the passed
5659 * querytree!
5660 *
5661 * We are only deparsing the query (we are not about to execute it), so we
5662 * only need AccessShareLock on the relations it mentions.
5663 */
5664 AcquireRewriteLocks(query, false, false);
5665
5666 context.buf = buf;
5667 context.namespaces = lcons(&dpns, list_copy(parentnamespace));
5668 context.resultDesc = NULL;
5669 context.targetList = NIL;
5670 context.windowClause = NIL;
5671 context.varprefix = (parentnamespace != NIL ||
5672 rtable_size != 1);
5673 context.prettyFlags = prettyFlags;
5674 context.wrapColumn = wrapColumn;
5675 context.indentLevel = startIndent;
5676 context.colNamesVisible = colNamesVisible;
5677 context.inGroupBy = false;
5678 context.varInOrderBy = false;
5679 context.appendparents = NULL;
5680
5681 set_deparse_for_query(&dpns, query, parentnamespace);
5682
5683 switch (query->commandType)
5684 {
5685 case CMD_SELECT:
5686 /* We set context.resultDesc only if it's a SELECT */
5687 context.resultDesc = resultDesc;
5688 get_select_query_def(query, &context);
5689 break;
5690
5691 case CMD_UPDATE:
5692 get_update_query_def(query, &context);
5693 break;
5694
5695 case CMD_INSERT:
5696 get_insert_query_def(query, &context);
5697 break;
5698
5699 case CMD_DELETE:
5700 get_delete_query_def(query, &context);
5701 break;
5702
5703 case CMD_MERGE:
5704 get_merge_query_def(query, &context);
5705 break;
5706
5707 case CMD_NOTHING:
5708 appendStringInfoString(buf, "NOTHING");
5709 break;
5710
5711 case CMD_UTILITY:
5712 get_utility_query_def(query, &context);
5713 break;
5714
5715 default:
5716 elog(ERROR, "unrecognized query command type: %d",
5717 query->commandType);
5718 break;
5719 }
5720}
5721
5722/* ----------
5723 * get_values_def - Parse back a VALUES list
5724 * ----------
5725 */
5726static void
5727get_values_def(List *values_lists, deparse_context *context)
5728{
5729 StringInfo buf = context->buf;
5730 bool first_list = true;
5731 ListCell *vtl;
5732
5733 appendStringInfoString(buf, "VALUES ");
5734
5735 foreach(vtl, values_lists)
5736 {
5737 List *sublist = (List *) lfirst(vtl);
5738 bool first_col = true;
5739 ListCell *lc;
5740
5741 if (first_list)
5742 first_list = false;
5743 else
5744 appendStringInfoString(buf, ", ");
5745
5746 appendStringInfoChar(buf, '(');
5747 foreach(lc, sublist)
5748 {
5749 Node *col = (Node *) lfirst(lc);
5750
5751 if (first_col)
5752 first_col = false;
5753 else
5754 appendStringInfoChar(buf, ',');
5755
5756 /*
5757 * Print the value. Whole-row Vars need special treatment.
5758 */
5759 get_rule_expr_toplevel(col, context, false);
5760 }
5761 appendStringInfoChar(buf, ')');
5762 }
5763}
5764
5765/* ----------
5766 * get_with_clause - Parse back a WITH clause
5767 * ----------
5768 */
5769static void
5770get_with_clause(Query *query, deparse_context *context)
5771{
5772 StringInfo buf = context->buf;
5773 const char *sep;
5774 ListCell *l;
5775
5776 if (query->cteList == NIL)
5777 return;
5778
5779 if (PRETTY_INDENT(context))
5780 {
5781 context->indentLevel += PRETTYINDENT_STD;
5782 appendStringInfoChar(buf, ' ');
5783 }
5784
5785 if (query->hasRecursive)
5786 sep = "WITH RECURSIVE ";
5787 else
5788 sep = "WITH ";
5789 foreach(l, query->cteList)
5790 {
5791 CommonTableExpr *cte = (CommonTableExpr *) lfirst(l);
5792
5793 appendStringInfoString(buf, sep);
5794 appendStringInfoString(buf, quote_identifier(cte->ctename));
5795 if (cte->aliascolnames)
5796 {
5797 bool first = true;
5798 ListCell *col;
5799
5800 appendStringInfoChar(buf, '(');
5801 foreach(col, cte->aliascolnames)
5802 {
5803 if (first)
5804 first = false;
5805 else
5806 appendStringInfoString(buf, ", ");
5807 appendStringInfoString(buf,
5808 quote_identifier(strVal(lfirst(col))));
5809 }
5810 appendStringInfoChar(buf, ')');
5811 }
5812 appendStringInfoString(buf, " AS ");
5813 switch (cte->ctematerialized)
5814 {
5815 case CTEMaterializeDefault:
5816 break;
5817 case CTEMaterializeAlways:
5818 appendStringInfoString(buf, "MATERIALIZED ");
5819 break;
5820 case CTEMaterializeNever:
5821 appendStringInfoString(buf, "NOT MATERIALIZED ");
5822 break;
5823 }
5824 appendStringInfoChar(buf, '(');
5825 if (PRETTY_INDENT(context))
5826 appendContextKeyword(context, "", 0, 0, 0);
5827 get_query_def((Query *) cte->ctequery, buf, context->namespaces, NULL,
5828 true,
5829 context->prettyFlags, context->wrapColumn,
5830 context->indentLevel);
5831 if (PRETTY_INDENT(context))
5832 appendContextKeyword(context, "", 0, 0, 0);
5833 appendStringInfoChar(buf, ')');
5834
5835 if (cte->search_clause)
5836 {
5837 bool first = true;
5838 ListCell *lc;
5839
5840 appendStringInfo(buf, " SEARCH %s FIRST BY ",
5841 cte->search_clause->search_breadth_first ? "BREADTH" : "DEPTH");
5842
5843 foreach(lc, cte->search_clause->search_col_list)
5844 {
5845 if (first)
5846 first = false;
5847 else
5848 appendStringInfoString(buf, ", ");
5849 appendStringInfoString(buf,
5850 quote_identifier(strVal(lfirst(lc))));
5851 }
5852
5853 appendStringInfo(buf, " SET %s", quote_identifier(cte->search_clause->search_seq_column));
5854 }
5855
5856 if (cte->cycle_clause)
5857 {
5858 bool first = true;
5859 ListCell *lc;
5860
5861 appendStringInfoString(buf, " CYCLE ");
5862
5863 foreach(lc, cte->cycle_clause->cycle_col_list)
5864 {
5865 if (first)
5866 first = false;
5867 else
5868 appendStringInfoString(buf, ", ");
5869 appendStringInfoString(buf,
5870 quote_identifier(strVal(lfirst(lc))));
5871 }
5872
5873 appendStringInfo(buf, " SET %s", quote_identifier(cte->cycle_clause->cycle_mark_column));
5874
5875 {
5876 Const *cmv = castNode(Const, cte->cycle_clause->cycle_mark_value);
5877 Const *cmd = castNode(Const, cte->cycle_clause->cycle_mark_default);
5878
5879 if (!(cmv->consttype == BOOLOID && !cmv->constisnull && DatumGetBool(cmv->constvalue) == true &&
5880 cmd->consttype == BOOLOID && !cmd->constisnull && DatumGetBool(cmd->constvalue) == false))
5881 {
5882 appendStringInfoString(buf, " TO ");
5883 get_rule_expr(cte->cycle_clause->cycle_mark_value, context, false);
5884 appendStringInfoString(buf, " DEFAULT ");
5885 get_rule_expr(cte->cycle_clause->cycle_mark_default, context, false);
5886 }
5887 }
5888
5889 appendStringInfo(buf, " USING %s", quote_identifier(cte->cycle_clause->cycle_path_column));
5890 }
5891
5892 sep = ", ";
5893 }
5894
5895 if (PRETTY_INDENT(context))
5896 {
5897 context->indentLevel -= PRETTYINDENT_STD;
5898 appendContextKeyword(context, "", 0, 0, 0);
5899 }
5900 else
5901 appendStringInfoChar(buf, ' ');
5902}
5903
5904/* ----------
5905 * get_select_query_def - Parse back a SELECT parsetree
5906 * ----------
5907 */
5908static void
5909get_select_query_def(Query *query, deparse_context *context)
5910{
5911 StringInfo buf = context->buf;
5912 bool force_colno;
5913 ListCell *l;
5914
5915 /* Insert the WITH clause if given */
5916 get_with_clause(query, context);
5917
5918 /* Subroutines may need to consult the SELECT targetlist and windowClause */
5919 context->targetList = query->targetList;
5920 context->windowClause = query->windowClause;
5921
5922 /*
5923 * If the Query node has a setOperations tree, then it's the top level of
5924 * a UNION/INTERSECT/EXCEPT query; only the WITH, ORDER BY and LIMIT
5925 * fields are interesting in the top query itself.
5926 */
5927 if (query->setOperations)
5928 {
5929 get_setop_query(query->setOperations, query, context);
5930 /* ORDER BY clauses must be simple in this case */
5931 force_colno = true;
5932 }
5933 else
5934 {
5935 get_basic_select_query(query, context);
5936 force_colno = false;
5937 }
5938
5939 /* Add the ORDER BY clause if given */
5940 if (query->sortClause != NIL)
5941 {
5942 appendContextKeyword(context, " ORDER BY ",
5943 -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
5944 get_rule_orderby(query->sortClause, query->targetList,
5945 force_colno, context);
5946 }
5947
5948 /*
5949 * Add the LIMIT/OFFSET clauses if given. If non-default options, use the
5950 * standard spelling of LIMIT.
5951 */
5952 if (query->limitOffset != NULL)
5953 {
5954 appendContextKeyword(context, " OFFSET ",
5955 -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
5956 get_rule_expr(query->limitOffset, context, false);
5957 }
5958 if (query->limitCount != NULL)
5959 {
5960 if (query->limitOption == LIMIT_OPTION_WITH_TIES)
5961 {
5962 /*
5963 * The limitCount arg is a c_expr, so it needs parens. Simple
5964 * literals and function expressions would not need parens, but
5965 * unfortunately it's hard to tell if the expression will be
5966 * printed as a simple literal like 123 or as a typecast
5967 * expression, like '-123'::int4. The grammar accepts the former
5968 * without quoting, but not the latter.
5969 */
5970 appendContextKeyword(context, " FETCH FIRST ",
5971 -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
5972 appendStringInfoChar(buf, '(');
5973 get_rule_expr(query->limitCount, context, false);
5974 appendStringInfoChar(buf, ')');
5975 appendStringInfoString(buf, " ROWS WITH TIES");
5976 }
5977 else
5978 {
5979 appendContextKeyword(context, " LIMIT ",
5980 -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
5981 if (IsA(query->limitCount, Const) &&
5982 ((Const *) query->limitCount)->constisnull)
5983 appendStringInfoString(buf, "ALL");
5984 else
5985 get_rule_expr(query->limitCount, context, false);
5986 }
5987 }
5988
5989 /* Add FOR [KEY] UPDATE/SHARE clauses if present */
5990 if (query->hasForUpdate)
5991 {
5992 foreach(l, query->rowMarks)
5993 {
5994 RowMarkClause *rc = (RowMarkClause *) lfirst(l);
5995
5996 /* don't print implicit clauses */
5997 if (rc->pushedDown)
5998 continue;
5999
6000 switch (rc->strength)
6001 {
6002 case LCS_NONE:
6003 /* we intentionally throw an error for LCS_NONE */
6004 elog(ERROR, "unrecognized LockClauseStrength %d",
6005 (int) rc->strength);
6006 break;
6007 case LCS_FORKEYSHARE:
6008 appendContextKeyword(context, " FOR KEY SHARE",
6009 -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
6010 break;
6011 case LCS_FORSHARE:
6012 appendContextKeyword(context, " FOR SHARE",
6013 -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
6014 break;
6015 case LCS_FORNOKEYUPDATE:
6016 appendContextKeyword(context, " FOR NO KEY UPDATE",
6017 -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
6018 break;
6019 case LCS_FORUPDATE:
6020 appendContextKeyword(context, " FOR UPDATE",
6021 -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
6022 break;
6023 }
6024
6025 appendStringInfo(buf, " OF %s",
6026 quote_identifier(get_rtable_name(rc->rti,
6027 context)));
6028 if (rc->waitPolicy == LockWaitError)
6029 appendStringInfoString(buf, " NOWAIT");
6030 else if (rc->waitPolicy == LockWaitSkip)
6031 appendStringInfoString(buf, " SKIP LOCKED");
6032 }
6033 }
6034}
6035
6036/*
6037 * Detect whether query looks like SELECT ... FROM VALUES(),
6038 * with no need to rename the output columns of the VALUES RTE.
6039 * If so, return the VALUES RTE. Otherwise return NULL.
6040 */
6041static RangeTblEntry *
6042get_simple_values_rte(Query *query, TupleDesc resultDesc)
6043{
6044 RangeTblEntry *result = NULL;
6045 ListCell *lc;
6046
6047 /*
6048 * We want to detect a match even if the Query also contains OLD or NEW
6049 * rule RTEs. So the idea is to scan the rtable and see if there is only
6050 * one inFromCl RTE that is a VALUES RTE.
6051 */
6052 foreach(lc, query->rtable)
6053 {
6054 RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
6055
6056 if (rte->rtekind == RTE_VALUES && rte->inFromCl)
6057 {
6058 if (result)
6059 return NULL; /* multiple VALUES (probably not possible) */
6060 result = rte;
6061 }
6062 else if (rte->rtekind == RTE_RELATION && !rte->inFromCl)
6063 continue; /* ignore rule entries */
6064 else
6065 return NULL; /* something else -> not simple VALUES */
6066 }
6067
6068 /*
6069 * We don't need to check the targetlist in any great detail, because
6070 * parser/analyze.c will never generate a "bare" VALUES RTE --- they only
6071 * appear inside auto-generated sub-queries with very restricted
6072 * structure. However, DefineView might have modified the tlist by
6073 * injecting new column aliases, or we might have some other column
6074 * aliases forced by a resultDesc. We can only simplify if the RTE's
6075 * column names match the names that get_target_list() would select.
6076 */
6077 if (result)
6078 {
6079 ListCell *lcn;
6080 int colno;
6081
6082 if (list_length(query->targetList) != list_length(result->eref->colnames))
6083 return NULL; /* this probably cannot happen */
6084 colno = 0;
6085 forboth(lc, query->targetList, lcn, result->eref->colnames)
6086 {
6087 TargetEntry *tle = (TargetEntry *) lfirst(lc);
6088 char *cname = strVal(lfirst(lcn));
6089 char *colname;
6090
6091 if (tle->resjunk)
6092 return NULL; /* this probably cannot happen */
6093
6094 /* compute name that get_target_list would use for column */
6095 colno++;
6096 if (resultDesc && colno <= resultDesc->natts)
6097 colname = NameStr(TupleDescAttr(resultDesc, colno - 1)->attname);
6098 else
6099 colname = tle->resname;
6100
6101 /* does it match the VALUES RTE? */
6102 if (colname == NULL || strcmp(colname, cname) != 0)
6103 return NULL; /* column name has been changed */
6104 }
6105 }
6106
6107 return result;
6108}
6109
6110static void
6111get_basic_select_query(Query *query, deparse_context *context)
6112{
6113 StringInfo buf = context->buf;
6114 RangeTblEntry *values_rte;
6115 char *sep;
6116 ListCell *l;
6117
6118 if (PRETTY_INDENT(context))
6119 {
6120 context->indentLevel += PRETTYINDENT_STD;
6121 appendStringInfoChar(buf, ' ');
6122 }
6123
6124 /*
6125 * If the query looks like SELECT * FROM (VALUES ...), then print just the
6126 * VALUES part. This reverses what transformValuesClause() did at parse
6127 * time.
6128 */
6129 values_rte = get_simple_values_rte(query, context->resultDesc);
6130 if (values_rte)
6131 {
6132 get_values_def(values_rte->values_lists, context);
6133 return;
6134 }
6135
6136 /*
6137 * Build up the query string - first we say SELECT
6138 */
6139 if (query->isReturn)
6140 appendStringInfoString(buf, "RETURN");
6141 else
6142 appendStringInfoString(buf, "SELECT");
6143
6144 /* Add the DISTINCT clause if given */
6145 if (query->distinctClause != NIL)
6146 {
6147 if (query->hasDistinctOn)
6148 {
6149 appendStringInfoString(buf, " DISTINCT ON (");
6150 sep = "";
6151 foreach(l, query->distinctClause)
6152 {
6153 SortGroupClause *srt = (SortGroupClause *) lfirst(l);
6154
6155 appendStringInfoString(buf, sep);
6156 get_rule_sortgroupclause(srt->tleSortGroupRef, query->targetList,
6157 false, context);
6158 sep = ", ";
6159 }
6160 appendStringInfoChar(buf, ')');
6161 }
6162 else
6163 appendStringInfoString(buf, " DISTINCT");
6164 }
6165
6166 /* Then we tell what to select (the targetlist) */
6167 get_target_list(query->targetList, context);
6168
6169 /* Add the FROM clause if needed */
6170 get_from_clause(query, " FROM ", context);
6171
6172 /* Add the WHERE clause if given */
6173 if (query->jointree->quals != NULL)
6174 {
6175 appendContextKeyword(context, " WHERE ",
6176 -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
6177 get_rule_expr(query->jointree->quals, context, false);
6178 }
6179
6180 /* Add the GROUP BY clause if given */
6181 if (query->groupClause != NULL || query->groupingSets != NULL)
6182 {
6183 bool save_ingroupby;
6184
6185 appendContextKeyword(context, " GROUP BY ",
6186 -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
6187 if (query->groupDistinct)
6188 appendStringInfoString(buf, "DISTINCT ");
6189
6190 save_ingroupby = context->inGroupBy;
6191 context->inGroupBy = true;
6192
6193 if (query->groupByAll)
6194 appendStringInfoString(buf, "ALL");
6195 else if (query->groupingSets == NIL)
6196 {
6197 sep = "";
6198 foreach(l, query->groupClause)
6199 {
6200 SortGroupClause *grp = (SortGroupClause *) lfirst(l);
6201
6202 appendStringInfoString(buf, sep);
6203 get_rule_sortgroupclause(grp->tleSortGroupRef, query->targetList,
6204 false, context);
6205 sep = ", ";
6206 }
6207 }
6208 else
6209 {
6210 sep = "";
6211 foreach(l, query->groupingSets)
6212 {
6213 GroupingSet *grp = lfirst(l);
6214
6215 appendStringInfoString(buf, sep);
6216 get_rule_groupingset(grp, query->targetList, true, context);
6217 sep = ", ";
6218 }
6219 }
6220
6221 context->inGroupBy = save_ingroupby;
6222 }
6223
6224 /* Add the HAVING clause if given */
6225 if (query->havingQual != NULL)
6226 {
6227 appendContextKeyword(context, " HAVING ",
6228 -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
6229 get_rule_expr(query->havingQual, context, false);
6230 }
6231
6232 /* Add the WINDOW clause if needed */
6233 if (query->windowClause != NIL)
6234 get_rule_windowclause(query, context);
6235}
6236
6237/* ----------
6238 * get_target_list - Parse back a SELECT target list
6239 *
6240 * This is also used for RETURNING lists in INSERT/UPDATE/DELETE/MERGE.
6241 * ----------
6242 */
6243static void
6244get_target_list(List *targetList, deparse_context *context)
6245{
6246 StringInfo buf = context->buf;
6247 StringInfoData targetbuf;
6248 bool last_was_multiline = false;
6249 char *sep;
6250 int colno;
6251 ListCell *l;
6252
6253 /* we use targetbuf to hold each TLE's text temporarily */
6254 initStringInfo(&targetbuf);
6255
6256 sep = " ";
6257 colno = 0;
6258 foreach(l, targetList)
6259 {
6260 TargetEntry *tle = (TargetEntry *) lfirst(l);
6261 char *colname;
6262 char *attname;
6263
6264 if (tle->resjunk)
6265 continue; /* ignore junk entries */
6266
6267 appendStringInfoString(buf, sep);
6268 sep = ", ";
6269 colno++;
6270
6271 /*
6272 * Put the new field text into targetbuf so we can decide after we've
6273 * got it whether or not it needs to go on a new line.
6274 */
6275 resetStringInfo(&targetbuf);
6276 context->buf = &targetbuf;
6277
6278 /*
6279 * We special-case Var nodes rather than using get_rule_expr. This is
6280 * needed because get_rule_expr will display a whole-row Var as
6281 * "foo.*", which is the preferred notation in most contexts, but at
6282 * the top level of a SELECT list it's not right (the parser will
6283 * expand that notation into multiple columns, yielding behavior
6284 * different from a whole-row Var). We need to call get_variable
6285 * directly so that we can tell it to do the right thing, and so that
6286 * we can get the attribute name which is the default AS label.
6287 */
6288 if (tle->expr && (IsA(tle->expr, Var)))
6289 {
6290 attname = get_variable((Var *) tle->expr, 0, true, context);
6291 }
6292 else
6293 {
6294 get_rule_expr((Node *) tle->expr, context, true);
6295
6296 /*
6297 * When colNamesVisible is true, we should always show the
6298 * assigned column name explicitly. Otherwise, show it only if
6299 * it's not FigureColname's fallback.
6300 */
6301 attname = context->colNamesVisible ? NULL : "?column?";
6302 }
6303
6304 /*
6305 * Figure out what the result column should be called. In the context
6306 * of a view, use the view's tuple descriptor (so as to pick up the
6307 * effects of any column RENAME that's been done on the view).
6308 * Otherwise, just use what we can find in the TLE.
6309 */
6310 if (context->resultDesc && colno <= context->resultDesc->natts)
6311 colname = NameStr(TupleDescAttr(context->resultDesc,
6312 colno - 1)->attname);
6313 else
6314 colname = tle->resname;
6315
6316 /* Show AS unless the column's name is correct as-is */
6317 if (colname) /* resname could be NULL */
6318 {
6319 if (attname == NULL || strcmp(attname, colname) != 0)
6320 appendStringInfo(&targetbuf, " AS %s", quote_identifier(colname));
6321 }
6322
6323 /* Restore context's output buffer */
6324 context->buf = buf;
6325
6326 /* Consider line-wrapping if enabled */
6327 if (PRETTY_INDENT(context) && context->wrapColumn >= 0)
6328 {
6329 int leading_nl_pos;
6330
6331 /* Does the new field start with a new line? */
6332 if (targetbuf.len > 0 && targetbuf.data[0] == '\n')
6333 leading_nl_pos = 0;
6334 else
6335 leading_nl_pos = -1;
6336
6337 /* If so, we shouldn't add anything */
6338 if (leading_nl_pos >= 0)
6339 {
6340 /* instead, remove any trailing spaces currently in buf */
6341 removeStringInfoSpaces(buf);
6342 }
6343 else
6344 {
6345 char *trailing_nl;
6346
6347 /* Locate the start of the current line in the output buffer */
6348 trailing_nl = strrchr(buf->data, '\n');
6349 if (trailing_nl == NULL)
6350 trailing_nl = buf->data;
6351 else
6352 trailing_nl++;
6353
6354 /*
6355 * Add a newline, plus some indentation, if the new field is
6356 * not the first and either the new field would cause an
6357 * overflow or the last field used more than one line.
6358 */
6359 if (colno > 1 &&
6360 ((strlen(trailing_nl) + targetbuf.len > context->wrapColumn) ||
6361 last_was_multiline))
6362 appendContextKeyword(context, "", -PRETTYINDENT_STD,
6363 PRETTYINDENT_STD, PRETTYINDENT_VAR);
6364 }
6365
6366 /* Remember this field's multiline status for next iteration */
6367 last_was_multiline =
6368 (strchr(targetbuf.data + leading_nl_pos + 1, '\n') != NULL);
6369 }
6370
6371 /* Add the new field */
6372 appendBinaryStringInfo(buf, targetbuf.data, targetbuf.len);
6373 }
6374
6375 /* clean up */
6376 pfree(targetbuf.data);
6377}
6378
6379static void
6380get_returning_clause(Query *query, deparse_context *context)
6381{
6382 StringInfo buf = context->buf;
6383
6384 if (query->returningList)
6385 {
6386 bool have_with = false;
6387
6388 appendContextKeyword(context, " RETURNING",
6389 -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
6390
6391 /* Add WITH (OLD/NEW) options, if they're not the defaults */
6392 if (query->returningOldAlias && strcmp(query->returningOldAlias, "old") != 0)
6393 {
6394 appendStringInfo(buf, " WITH (OLD AS %s",
6395 quote_identifier(query->returningOldAlias));
6396 have_with = true;
6397 }
6398 if (query->returningNewAlias && strcmp(query->returningNewAlias, "new") != 0)
6399 {
6400 if (have_with)
6401 appendStringInfo(buf, ", NEW AS %s",
6402 quote_identifier(query->returningNewAlias));
6403 else
6404 {
6405 appendStringInfo(buf, " WITH (NEW AS %s",
6406 quote_identifier(query->returningNewAlias));
6407 have_with = true;
6408 }
6409 }
6410 if (have_with)
6411 appendStringInfoChar(buf, ')');
6412
6413 /* Add the returning expressions themselves */
6414 get_target_list(query->returningList, context);
6415 }
6416}
6417
6418static void
6419get_setop_query(Node *setOp, Query *query, deparse_context *context)
6420{
6421 StringInfo buf = context->buf;
6422 bool need_paren;
6423
6424 /* Guard against excessively long or deeply-nested queries */
6425 CHECK_FOR_INTERRUPTS();
6426 check_stack_depth();
6427
6428 if (IsA(setOp, RangeTblRef))
6429 {
6430 RangeTblRef *rtr = (RangeTblRef *) setOp;
6431 RangeTblEntry *rte = rt_fetch(rtr->rtindex, query->rtable);
6432 Query *subquery = rte->subquery;
6433
6434 Assert(subquery != NULL);
6435
6436 /*
6437 * We need parens if WITH, ORDER BY, FOR UPDATE, or LIMIT; see gram.y.
6438 * Also add parens if the leaf query contains its own set operations.
6439 * (That shouldn't happen unless one of the other clauses is also
6440 * present, see transformSetOperationTree; but let's be safe.)
6441 */
6442 need_paren = (subquery->cteList ||
6443 subquery->sortClause ||
6444 subquery->rowMarks ||
6445 subquery->limitOffset ||
6446 subquery->limitCount ||
6447 subquery->setOperations);
6448 if (need_paren)
6449 appendStringInfoChar(buf, '(');
6450 get_query_def(subquery, buf, context->namespaces,
6451 context->resultDesc, context->colNamesVisible,
6452 context->prettyFlags, context->wrapColumn,
6453 context->indentLevel);
6454 if (need_paren)
6455 appendStringInfoChar(buf, ')');
6456 }
6457 else if (IsA(setOp, SetOperationStmt))
6458 {
6459 SetOperationStmt *op = (SetOperationStmt *) setOp;
6460 int subindent;
6461 bool save_colnamesvisible;
6462
6463 /*
6464 * We force parens when nesting two SetOperationStmts, except when the
6465 * lefthand input is another setop of the same kind. Syntactically,
6466 * we could omit parens in rather more cases, but it seems best to use
6467 * parens to flag cases where the setop operator changes. If we use
6468 * parens, we also increase the indentation level for the child query.
6469 *
6470 * There are some cases in which parens are needed around a leaf query
6471 * too, but those are more easily handled at the next level down (see
6472 * code above).
6473 */
6474 if (IsA(op->larg, SetOperationStmt))
6475 {
6476 SetOperationStmt *lop = (SetOperationStmt *) op->larg;
6477
6478 if (op->op == lop->op && op->all == lop->all)
6479 need_paren = false;
6480 else
6481 need_paren = true;
6482 }
6483 else
6484 need_paren = false;
6485
6486 if (need_paren)
6487 {
6488 appendStringInfoChar(buf, '(');
6489 subindent = PRETTYINDENT_STD;
6490 appendContextKeyword(context, "", subindent, 0, 0);
6491 }
6492 else
6493 subindent = 0;
6494
6495 get_setop_query(op->larg, query, context);
6496
6497 if (need_paren)
6498 appendContextKeyword(context, ") ", -subindent, 0, 0);
6499 else if (PRETTY_INDENT(context))
6500 appendContextKeyword(context, "", -subindent, 0, 0);
6501 else
6502 appendStringInfoChar(buf, ' ');
6503
6504 switch (op->op)
6505 {
6506 case SETOP_UNION:
6507 appendStringInfoString(buf, "UNION ");
6508 break;
6509 case SETOP_INTERSECT:
6510 appendStringInfoString(buf, "INTERSECT ");
6511 break;
6512 case SETOP_EXCEPT:
6513 appendStringInfoString(buf, "EXCEPT ");
6514 break;
6515 default:
6516 elog(ERROR, "unrecognized set op: %d",
6517 (int) op->op);
6518 }
6519 if (op->all)
6520 appendStringInfoString(buf, "ALL ");
6521
6522 /* Always parenthesize if RHS is another setop */
6523 need_paren = IsA(op->rarg, SetOperationStmt);
6524
6525 /*
6526 * The indentation code here is deliberately a bit different from that
6527 * for the lefthand input, because we want the line breaks in
6528 * different places.
6529 */
6530 if (need_paren)
6531 {
6532 appendStringInfoChar(buf, '(');
6533 subindent = PRETTYINDENT_STD;
6534 }
6535 else
6536 subindent = 0;
6537 appendContextKeyword(context, "", subindent, 0, 0);
6538
6539 /*
6540 * The output column names of the RHS sub-select don't matter.
6541 */
6542 save_colnamesvisible = context->colNamesVisible;
6543 context->colNamesVisible = false;
6544
6545 get_setop_query(op->rarg, query, context);
6546
6547 context->colNamesVisible = save_colnamesvisible;
6548
6549 if (PRETTY_INDENT(context))
6550 context->indentLevel -= subindent;
6551 if (need_paren)
6552 appendContextKeyword(context, ")", 0, 0, 0);
6553 }
6554 else
6555 {
6556 elog(ERROR, "unrecognized node type: %d",
6557 (int) nodeTag(setOp));
6558 }
6559}
6560
6561/*
6562 * Display a sort/group clause.
6563 *
6564 * Also returns the expression tree, so caller need not find it again.
6565 */
6566static Node *
6567get_rule_sortgroupclause(Index ref, List *tlist, bool force_colno,
6568 deparse_context *context)
6569{
6570 StringInfo buf = context->buf;
6571 TargetEntry *tle;
6572 Node *expr;
6573
6574 tle = get_sortgroupref_tle(ref, tlist);
6575 expr = (Node *) tle->expr;
6576
6577 /*
6578 * Use column-number form if requested by caller. Otherwise, if
6579 * expression is a constant, force it to be dumped with an explicit cast
6580 * as decoration --- this is because a simple integer constant is
6581 * ambiguous (and will be misinterpreted by findTargetlistEntrySQL92()) if
6582 * we dump it without any decoration. Similarly, if it's just a Var,
6583 * there is risk of misinterpretation if the column name is reassigned in
6584 * the SELECT list, so we may need to force table qualification. And, if
6585 * it's anything more complex than a simple Var, then force extra parens
6586 * around it, to ensure it can't be misinterpreted as a cube() or rollup()
6587 * construct.
6588 */
6589 if (force_colno)
6590 {
6591 Assert(!tle->resjunk);
6592 appendStringInfo(buf, "%d", tle->resno);
6593 }
6594 else if (!expr)
6595 /* do nothing, probably can't happen */ ;
6596 else if (IsA(expr, Const))
6597 get_const_expr((Const *) expr, context, 1);
6598 else if (IsA(expr, Var))
6599 {
6600 /* Tell get_variable to check for name conflict */
6601 bool save_varinorderby = context->varInOrderBy;
6602
6603 context->varInOrderBy = true;
6604 (void) get_variable((Var *) expr, 0, false, context);
6605 context->varInOrderBy = save_varinorderby;
6606 }
6607 else
6608 {
6609 /*
6610 * We must force parens for function-like expressions even if
6611 * PRETTY_PAREN is off, since those are the ones in danger of
6612 * misparsing. For other expressions we need to force them only if
6613 * PRETTY_PAREN is on, since otherwise the expression will output them
6614 * itself. (We can't skip the parens.)
6615 */
6616 bool need_paren = (PRETTY_PAREN(context)
6617 || IsA(expr, FuncExpr)
6618 || IsA(expr, Aggref)
6619 || IsA(expr, WindowFunc)
6620 || IsA(expr, JsonConstructorExpr));
6621
6622 if (need_paren)
6623 appendStringInfoChar(context->buf, '(');
6624 get_rule_expr(expr, context, true);
6625 if (need_paren)
6626 appendStringInfoChar(context->buf, ')');
6627 }
6628
6629 return expr;
6630}
6631
6632/*
6633 * Display a GroupingSet
6634 */
6635static void
6636get_rule_groupingset(GroupingSet *gset, List *targetlist,
6637 bool omit_parens, deparse_context *context)
6638{
6639 ListCell *l;
6640 StringInfo buf = context->buf;
6641 bool omit_child_parens = true;
6642 char *sep = "";
6643
6644 switch (gset->kind)
6645 {
6646 case GROUPING_SET_EMPTY:
6647 appendStringInfoString(buf, "()");
6648 return;
6649
6650 case GROUPING_SET_SIMPLE:
6651 {
6652 if (!omit_parens || list_length(gset->content) != 1)
6653 appendStringInfoChar(buf, '(');
6654
6655 foreach(l, gset->content)
6656 {
6657 Index ref = lfirst_int(l);
6658
6659 appendStringInfoString(buf, sep);
6660 get_rule_sortgroupclause(ref, targetlist,
6661 false, context);
6662 sep = ", ";
6663 }
6664
6665 if (!omit_parens || list_length(gset->content) != 1)
6666 appendStringInfoChar(buf, ')');
6667 }
6668 return;
6669
6670 case GROUPING_SET_ROLLUP:
6671 appendStringInfoString(buf, "ROLLUP(");
6672 break;
6673 case GROUPING_SET_CUBE:
6674 appendStringInfoString(buf, "CUBE(");
6675 break;
6676 case GROUPING_SET_SETS:
6677 appendStringInfoString(buf, "GROUPING SETS (");
6678 omit_child_parens = false;
6679 break;
6680 }
6681
6682 foreach(l, gset->content)
6683 {
6684 appendStringInfoString(buf, sep);
6685 get_rule_groupingset(lfirst(l), targetlist, omit_child_parens, context);
6686 sep = ", ";
6687 }
6688
6689 appendStringInfoChar(buf, ')');
6690}
6691
6692/*
6693 * Display an ORDER BY list.
6694 */
6695static void
6696get_rule_orderby(List *orderList, List *targetList,
6697 bool force_colno, deparse_context *context)
6698{
6699 StringInfo buf = context->buf;
6700 const char *sep;
6701 ListCell *l;
6702
6703 sep = "";
6704 foreach(l, orderList)
6705 {
6706 SortGroupClause *srt = (SortGroupClause *) lfirst(l);
6707 Node *sortexpr;
6708 Oid sortcoltype;
6709 TypeCacheEntry *typentry;
6710
6711 appendStringInfoString(buf, sep);
6712 sortexpr = get_rule_sortgroupclause(srt->tleSortGroupRef, targetList,
6713 force_colno, context);
6714 sortcoltype = exprType(sortexpr);
6715 /* See whether operator is default < or > for datatype */
6716 typentry = lookup_type_cache(sortcoltype,
6717 TYPECACHE_LT_OPR | TYPECACHE_GT_OPR);
6718 if (srt->sortop == typentry->lt_opr)
6719 {
6720 /* ASC is default, so emit nothing for it */
6721 if (srt->nulls_first)
6722 appendStringInfoString(buf, " NULLS FIRST");
6723 }
6724 else if (srt->sortop == typentry->gt_opr)
6725 {
6726 appendStringInfoString(buf, " DESC");
6727 /* DESC defaults to NULLS FIRST */
6728 if (!srt->nulls_first)
6729 appendStringInfoString(buf, " NULLS LAST");
6730 }
6731 else
6732 {
6733 appendStringInfo(buf, " USING %s",
6734 generate_operator_name(srt->sortop,
6735 sortcoltype,
6736 sortcoltype));
6737 /* be specific to eliminate ambiguity */
6738 if (srt->nulls_first)
6739 appendStringInfoString(buf, " NULLS FIRST");
6740 else
6741 appendStringInfoString(buf, " NULLS LAST");
6742 }
6743 sep = ", ";
6744 }
6745}
6746
6747/*
6748 * Display a WINDOW clause.
6749 *
6750 * Note that the windowClause list might contain only anonymous window
6751 * specifications, in which case we should print nothing here.
6752 */
6753static void
6754get_rule_windowclause(Query *query, deparse_context *context)
6755{
6756 StringInfo buf = context->buf;
6757 const char *sep;
6758 ListCell *l;
6759
6760 sep = NULL;
6761 foreach(l, query->windowClause)
6762 {
6763 WindowClause *wc = (WindowClause *) lfirst(l);
6764
6765 if (wc->name == NULL)
6766 continue; /* ignore anonymous windows */
6767
6768 if (sep == NULL)
6769 appendContextKeyword(context, " WINDOW ",
6770 -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
6771 else
6772 appendStringInfoString(buf, sep);
6773
6774 appendStringInfo(buf, "%s AS ", quote_identifier(wc->name));
6775
6776 get_rule_windowspec(wc, query->targetList, context);
6777
6778 sep = ", ";
6779 }
6780}
6781
6782/*
6783 * Display a window definition
6784 */
6785static void
6786get_rule_windowspec(WindowClause *wc, List *targetList,
6787 deparse_context *context)
6788{
6789 StringInfo buf = context->buf;
6790 bool needspace = false;
6791 const char *sep;
6792 ListCell *l;
6793
6794 appendStringInfoChar(buf, '(');
6795 if (wc->refname)
6796 {
6797 appendStringInfoString(buf, quote_identifier(wc->refname));
6798 needspace = true;
6799 }
6800 /* partition clauses are always inherited, so only print if no refname */
6801 if (wc->partitionClause && !wc->refname)
6802 {
6803 if (needspace)
6804 appendStringInfoChar(buf, ' ');
6805 appendStringInfoString(buf, "PARTITION BY ");
6806 sep = "";
6807 foreach(l, wc->partitionClause)
6808 {
6809 SortGroupClause *grp = (SortGroupClause *) lfirst(l);
6810
6811 appendStringInfoString(buf, sep);
6812 get_rule_sortgroupclause(grp->tleSortGroupRef, targetList,
6813 false, context);
6814 sep = ", ";
6815 }
6816 needspace = true;
6817 }
6818 /* print ordering clause only if not inherited */
6819 if (wc->orderClause && !wc->copiedOrder)
6820 {
6821 if (needspace)
6822 appendStringInfoChar(buf, ' ');
6823 appendStringInfoString(buf, "ORDER BY ");
6824 get_rule_orderby(wc->orderClause, targetList, false, context);
6825 needspace = true;
6826 }
6827 /* framing clause is never inherited, so print unless it's default */
6828 if (wc->frameOptions & FRAMEOPTION_NONDEFAULT)
6829 {
6830 if (needspace)
6831 appendStringInfoChar(buf, ' ');
6832 get_window_frame_options(wc->frameOptions,
6833 wc->startOffset, wc->endOffset,
6834 context);
6835 }
6836 appendStringInfoChar(buf, ')');
6837}
6838
6839/*
6840 * Append the description of a window's framing options to context->buf
6841 */
6842static void
6843get_window_frame_options(int frameOptions,
6844 Node *startOffset, Node *endOffset,
6845 deparse_context *context)
6846{
6847 StringInfo buf = context->buf;
6848
6849 if (frameOptions & FRAMEOPTION_NONDEFAULT)
6850 {
6851 if (frameOptions & FRAMEOPTION_RANGE)
6852 appendStringInfoString(buf, "RANGE ");
6853 else if (frameOptions & FRAMEOPTION_ROWS)
6854 appendStringInfoString(buf, "ROWS ");
6855 else if (frameOptions & FRAMEOPTION_GROUPS)
6856 appendStringInfoString(buf, "GROUPS ");
6857 else
6858 Assert(false);
6859 if (frameOptions & FRAMEOPTION_BETWEEN)
6860 appendStringInfoString(buf, "BETWEEN ");
6861 if (frameOptions & FRAMEOPTION_START_UNBOUNDED_PRECEDING)
6862 appendStringInfoString(buf, "UNBOUNDED PRECEDING ");
6863 else if (frameOptions & FRAMEOPTION_START_CURRENT_ROW)
6864 appendStringInfoString(buf, "CURRENT ROW ");
6865 else if (frameOptions & FRAMEOPTION_START_OFFSET)
6866 {
6867 get_rule_expr(startOffset, context, false);
6868 if (frameOptions & FRAMEOPTION_START_OFFSET_PRECEDING)
6869 appendStringInfoString(buf, " PRECEDING ");
6870 else if (frameOptions & FRAMEOPTION_START_OFFSET_FOLLOWING)
6871 appendStringInfoString(buf, " FOLLOWING ");
6872 else
6873 Assert(false);
6874 }
6875 else
6876 Assert(false);
6877 if (frameOptions & FRAMEOPTION_BETWEEN)
6878 {
6879 appendStringInfoString(buf, "AND ");
6880 if (frameOptions & FRAMEOPTION_END_UNBOUNDED_FOLLOWING)
6881 appendStringInfoString(buf, "UNBOUNDED FOLLOWING ");
6882 else if (frameOptions & FRAMEOPTION_END_CURRENT_ROW)
6883 appendStringInfoString(buf, "CURRENT ROW ");
6884 else if (frameOptions & FRAMEOPTION_END_OFFSET)
6885 {
6886 get_rule_expr(endOffset, context, false);
6887 if (frameOptions & FRAMEOPTION_END_OFFSET_PRECEDING)
6888 appendStringInfoString(buf, " PRECEDING ");
6889 else if (frameOptions & FRAMEOPTION_END_OFFSET_FOLLOWING)
6890 appendStringInfoString(buf, " FOLLOWING ");
6891 else
6892 Assert(false);
6893 }
6894 else
6895 Assert(false);
6896 }
6897 if (frameOptions & FRAMEOPTION_EXCLUDE_CURRENT_ROW)
6898 appendStringInfoString(buf, "EXCLUDE CURRENT ROW ");
6899 else if (frameOptions & FRAMEOPTION_EXCLUDE_GROUP)
6900 appendStringInfoString(buf, "EXCLUDE GROUP ");
6901 else if (frameOptions & FRAMEOPTION_EXCLUDE_TIES)
6902 appendStringInfoString(buf, "EXCLUDE TIES ");
6903 /* we will now have a trailing space; remove it */
6904 buf->data[--(buf->len)] = '\0';
6905 }
6906}
6907
6908/*
6909 * Return the description of a window's framing options as a palloc'd string
6910 */
6911char *
6912get_window_frame_options_for_explain(int frameOptions,
6913 Node *startOffset, Node *endOffset,
6914 List *dpcontext, bool forceprefix)
6915{
6916 StringInfoData buf;
6917 deparse_context context;
6918
6919 initStringInfo(&buf);
6920 context.buf = &buf;
6921 context.namespaces = dpcontext;
6922 context.resultDesc = NULL;
6923 context.targetList = NIL;
6924 context.windowClause = NIL;
6925 context.varprefix = forceprefix;
6926 context.prettyFlags = 0;
6927 context.wrapColumn = WRAP_COLUMN_DEFAULT;
6928 context.indentLevel = 0;
6929 context.colNamesVisible = true;
6930 context.inGroupBy = false;
6931 context.varInOrderBy = false;
6932 context.appendparents = NULL;
6933
6934 get_window_frame_options(frameOptions, startOffset, endOffset, &context);
6935
6936 return buf.data;
6937}
6938
6939/* ----------
6940 * get_insert_query_def - Parse back an INSERT parsetree
6941 * ----------
6942 */
6943static void
6944get_insert_query_def(Query *query, deparse_context *context)
6945{
6946 StringInfo buf = context->buf;
6947 RangeTblEntry *select_rte = NULL;
6948 RangeTblEntry *values_rte = NULL;
6949 RangeTblEntry *rte;
6950 char *sep;
6951 ListCell *l;
6952 List *strippedexprs;
6953
6954 /* Insert the WITH clause if given */
6955 get_with_clause(query, context);
6956
6957 /*
6958 * If it's an INSERT ... SELECT or multi-row VALUES, there will be a
6959 * single RTE for the SELECT or VALUES. Plain VALUES has neither.
6960 */
6961 foreach(l, query->rtable)
6962 {
6963 rte = (RangeTblEntry *) lfirst(l);
6964
6965 if (rte->rtekind == RTE_SUBQUERY)
6966 {
6967 if (select_rte)
6968 elog(ERROR, "too many subquery RTEs in INSERT");
6969 select_rte = rte;
6970 }
6971
6972 if (rte->rtekind == RTE_VALUES)
6973 {
6974 if (values_rte)
6975 elog(ERROR, "too many values RTEs in INSERT");
6976 values_rte = rte;
6977 }
6978 }
6979 if (select_rte && values_rte)
6980 elog(ERROR, "both subquery and values RTEs in INSERT");
6981
6982 /*
6983 * Start the query with INSERT INTO relname
6984 */
6985 rte = rt_fetch(query->resultRelation, query->rtable);
6986 Assert(rte->rtekind == RTE_RELATION);
6987
6988 if (PRETTY_INDENT(context))
6989 {
6990 context->indentLevel += PRETTYINDENT_STD;
6991 appendStringInfoChar(buf, ' ');
6992 }
6993 appendStringInfo(buf, "INSERT INTO %s",
6994 generate_relation_name(rte->relid, NIL));
6995
6996 /* Print the relation alias, if needed; INSERT requires explicit AS */
6997 get_rte_alias(rte, query->resultRelation, true, context);
6998
6999 /* always want a space here */
7000 appendStringInfoChar(buf, ' ');
7001
7002 /*
7003 * Add the insert-column-names list. Any indirection decoration needed on
7004 * the column names can be inferred from the top targetlist.
7005 */
7006 strippedexprs = NIL;
7007 sep = "";
7008 if (query->targetList)
7009 appendStringInfoChar(buf, '(');
7010 foreach(l, query->targetList)
7011 {
7012 TargetEntry *tle = (TargetEntry *) lfirst(l);
7013
7014 if (tle->resjunk)
7015 continue; /* ignore junk entries */
7016
7017 appendStringInfoString(buf, sep);
7018 sep = ", ";
7019
7020 /*
7021 * Put out name of target column; look in the catalogs, not at
7022 * tle->resname, since resname will fail to track RENAME.
7023 */
7024 appendStringInfoString(buf,
7025 quote_identifier(get_attname(rte->relid,
7026 tle->resno,
7027 false)));
7028
7029 /*
7030 * Print any indirection needed (subfields or subscripts), and strip
7031 * off the top-level nodes representing the indirection assignments.
7032 * Add the stripped expressions to strippedexprs. (If it's a
7033 * single-VALUES statement, the stripped expressions are the VALUES to
7034 * print below. Otherwise they're just Vars and not really
7035 * interesting.)
7036 */
7037 strippedexprs = lappend(strippedexprs,
7038 processIndirection((Node *) tle->expr,
7039 context));
7040 }
7041 if (query->targetList)
7042 appendStringInfoString(buf, ") ");
7043
7044 if (query->override)
7045 {
7046 if (query->override == OVERRIDING_SYSTEM_VALUE)
7047 appendStringInfoString(buf, "OVERRIDING SYSTEM VALUE ");
7048 else if (query->override == OVERRIDING_USER_VALUE)
7049 appendStringInfoString(buf, "OVERRIDING USER VALUE ");
7050 }
7051
7052 if (select_rte)
7053 {
7054 /* Add the SELECT */
7055 get_query_def(select_rte->subquery, buf, context->namespaces, NULL,
7056 false,
7057 context->prettyFlags, context->wrapColumn,
7058 context->indentLevel);
7059 }
7060 else if (values_rte)
7061 {
7062 /* Add the multi-VALUES expression lists */
7063 get_values_def(values_rte->values_lists, context);
7064 }
7065 else if (strippedexprs)
7066 {
7067 /* Add the single-VALUES expression list */
7068 appendContextKeyword(context, "VALUES (",
7069 -PRETTYINDENT_STD, PRETTYINDENT_STD, 2);
7070 get_rule_list_toplevel(strippedexprs, context, false);
7071 appendStringInfoChar(buf, ')');
7072 }
7073 else
7074 {
7075 /* No expressions, so it must be DEFAULT VALUES */
7076 appendStringInfoString(buf, "DEFAULT VALUES");
7077 }
7078
7079 /* Add ON CONFLICT if present */
7080 if (query->onConflict)
7081 {
7082 OnConflictExpr *confl = query->onConflict;
7083
7084 appendStringInfoString(buf, " ON CONFLICT");
7085
7086 if (confl->arbiterElems)
7087 {
7088 /* Add the single-VALUES expression list */
7089 appendStringInfoChar(buf, '(');
7090 get_rule_expr((Node *) confl->arbiterElems, context, false);
7091 appendStringInfoChar(buf, ')');
7092
7093 /* Add a WHERE clause (for partial indexes) if given */
7094 if (confl->arbiterWhere != NULL)
7095 {
7096 bool save_varprefix;
7097
7098 /*
7099 * Force non-prefixing of Vars, since parser assumes that they
7100 * belong to target relation. WHERE clause does not use
7101 * InferenceElem, so this is separately required.
7102 */
7103 save_varprefix = context->varprefix;
7104 context->varprefix = false;
7105
7106 appendContextKeyword(context, " WHERE ",
7107 -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
7108 get_rule_expr(confl->arbiterWhere, context, false);
7109
7110 context->varprefix = save_varprefix;
7111 }
7112 }
7113 else if (OidIsValid(confl->constraint))
7114 {
7115 char *constraint = get_constraint_name(confl->constraint);
7116
7117 if (!constraint)
7118 elog(ERROR, "cache lookup failed for constraint %u",
7119 confl->constraint);
7120 appendStringInfo(buf, " ON CONSTRAINT %s",
7121 quote_identifier(constraint));
7122 }
7123
7124 if (confl->action == ONCONFLICT_NOTHING)
7125 {
7126 appendStringInfoString(buf, " DO NOTHING");
7127 }
7128 else
7129 {
7130 appendStringInfoString(buf, " DO UPDATE SET ");
7131 /* Deparse targetlist */
7132 get_update_query_targetlist_def(query, confl->onConflictSet,
7133 context, rte);
7134
7135 /* Add a WHERE clause if given */
7136 if (confl->onConflictWhere != NULL)
7137 {
7138 appendContextKeyword(context, " WHERE ",
7139 -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
7140 get_rule_expr(confl->onConflictWhere, context, false);
7141 }
7142 }
7143 }
7144
7145 /* Add RETURNING if present */
7146 if (query->returningList)
7147 get_returning_clause(query, context);
7148}
7149
7150
7151/* ----------
7152 * get_update_query_def - Parse back an UPDATE parsetree
7153 * ----------
7154 */
7155static void
7156get_update_query_def(Query *query, deparse_context *context)
7157{
7158 StringInfo buf = context->buf;
7159 RangeTblEntry *rte;
7160
7161 /* Insert the WITH clause if given */
7162 get_with_clause(query, context);
7163
7164 /*
7165 * Start the query with UPDATE relname SET
7166 */
7167 rte = rt_fetch(query->resultRelation, query->rtable);
7168 Assert(rte->rtekind == RTE_RELATION);
7169 if (PRETTY_INDENT(context))
7170 {
7171 appendStringInfoChar(buf, ' ');
7172 context->indentLevel += PRETTYINDENT_STD;
7173 }
7174 appendStringInfo(buf, "UPDATE %s%s",
7175 only_marker(rte),
7176 generate_relation_name(rte->relid, NIL));
7177
7178 /* Print the relation alias, if needed */
7179 get_rte_alias(rte, query->resultRelation, false, context);
7180
7181 appendStringInfoString(buf, " SET ");
7182
7183 /* Deparse targetlist */
7184 get_update_query_targetlist_def(query, query->targetList, context, rte);
7185
7186 /* Add the FROM clause if needed */
7187 get_from_clause(query, " FROM ", context);
7188
7189 /* Add a WHERE clause if given */
7190 if (query->jointree->quals != NULL)
7191 {
7192 appendContextKeyword(context, " WHERE ",
7193 -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
7194 get_rule_expr(query->jointree->quals, context, false);
7195 }
7196
7197 /* Add RETURNING if present */
7198 if (query->returningList)
7199 get_returning_clause(query, context);
7200}
7201
7202
7203/* ----------
7204 * get_update_query_targetlist_def - Parse back an UPDATE targetlist
7205 * ----------
7206 */
7207static void
7208get_update_query_targetlist_def(Query *query, List *targetList,
7209 deparse_context *context, RangeTblEntry *rte)
7210{
7211 StringInfo buf = context->buf;
7212 ListCell *l;
7213 ListCell *next_ma_cell;
7214 int remaining_ma_columns;
7215 const char *sep;
7216 SubLink *cur_ma_sublink;
7217 List *ma_sublinks;
7218
7219 /*
7220 * Prepare to deal with MULTIEXPR assignments: collect the source SubLinks
7221 * into a list. We expect them to appear, in ID order, in resjunk tlist
7222 * entries.
7223 */
7224 ma_sublinks = NIL;
7225 if (query->hasSubLinks) /* else there can't be any */
7226 {
7227 foreach(l, targetList)
7228 {
7229 TargetEntry *tle = (TargetEntry *) lfirst(l);
7230
7231 if (tle->resjunk && IsA(tle->expr, SubLink))
7232 {
7233 SubLink *sl = (SubLink *) tle->expr;
7234
7235 if (sl->subLinkType == MULTIEXPR_SUBLINK)
7236 {
7237 ma_sublinks = lappend(ma_sublinks, sl);
7238 Assert(sl->subLinkId == list_length(ma_sublinks));
7239 }
7240 }
7241 }
7242 }
7243 next_ma_cell = list_head(ma_sublinks);
7244 cur_ma_sublink = NULL;
7245 remaining_ma_columns = 0;
7246
7247 /* Add the comma separated list of 'attname = value' */
7248 sep = "";
7249 foreach(l, targetList)
7250 {
7251 TargetEntry *tle = (TargetEntry *) lfirst(l);
7252 Node *expr;
7253
7254 if (tle->resjunk)
7255 continue; /* ignore junk entries */
7256
7257 /* Emit separator (OK whether we're in multiassignment or not) */
7258 appendStringInfoString(buf, sep);
7259 sep = ", ";
7260
7261 /*
7262 * Check to see if we're starting a multiassignment group: if so,
7263 * output a left paren.
7264 */
7265 if (next_ma_cell != NULL && cur_ma_sublink == NULL)
7266 {
7267 /*
7268 * We must dig down into the expr to see if it's a PARAM_MULTIEXPR
7269 * Param. That could be buried under FieldStores and
7270 * SubscriptingRefs and CoerceToDomains (cf processIndirection()),
7271 * and underneath those there could be an implicit type coercion.
7272 * Because we would ignore implicit type coercions anyway, we
7273 * don't need to be as careful as processIndirection() is about
7274 * descending past implicit CoerceToDomains.
7275 */
7276 expr = (Node *) tle->expr;
7277 while (expr)
7278 {
7279 if (IsA(expr, FieldStore))
7280 {
7281 FieldStore *fstore = (FieldStore *) expr;
7282
7283 expr = (Node *) linitial(fstore->newvals);
7284 }
7285 else if (IsA(expr, SubscriptingRef))
7286 {
7287 SubscriptingRef *sbsref = (SubscriptingRef *) expr;
7288
7289 if (sbsref->refassgnexpr == NULL)
7290 break;
7291
7292 expr = (Node *) sbsref->refassgnexpr;
7293 }
7294 else if (IsA(expr, CoerceToDomain))
7295 {
7296 CoerceToDomain *cdomain = (CoerceToDomain *) expr;
7297
7298 if (cdomain->coercionformat != COERCE_IMPLICIT_CAST)
7299 break;
7300 expr = (Node *) cdomain->arg;
7301 }
7302 else
7303 break;
7304 }
7305 expr = strip_implicit_coercions(expr);
7306
7307 if (expr && IsA(expr, Param) &&
7308 ((Param *) expr)->paramkind == PARAM_MULTIEXPR)
7309 {
7310 cur_ma_sublink = (SubLink *) lfirst(next_ma_cell);
7311 next_ma_cell = lnext(ma_sublinks, next_ma_cell);
7312 remaining_ma_columns = count_nonjunk_tlist_entries(((Query *) cur_ma_sublink->subselect)->targetList);
7313 Assert(((Param *) expr)->paramid ==
7314 ((cur_ma_sublink->subLinkId << 16) | 1));
7315 appendStringInfoChar(buf, '(');
7316 }
7317 }
7318
7319 /*
7320 * Put out name of target column; look in the catalogs, not at
7321 * tle->resname, since resname will fail to track RENAME.
7322 */
7323 appendStringInfoString(buf,
7324 quote_identifier(get_attname(rte->relid,
7325 tle->resno,
7326 false)));
7327
7328 /*
7329 * Print any indirection needed (subfields or subscripts), and strip
7330 * off the top-level nodes representing the indirection assignments.
7331 */
7332 expr = processIndirection((Node *) tle->expr, context);
7333
7334 /*
7335 * If we're in a multiassignment, skip printing anything more, unless
7336 * this is the last column; in which case, what we print should be the
7337 * sublink, not the Param.
7338 */
7339 if (cur_ma_sublink != NULL)
7340 {
7341 if (--remaining_ma_columns > 0)
7342 continue; /* not the last column of multiassignment */
7343 appendStringInfoChar(buf, ')');
7344 expr = (Node *) cur_ma_sublink;
7345 cur_ma_sublink = NULL;
7346 }
7347
7348 appendStringInfoString(buf, " = ");
7349
7350 get_rule_expr(expr, context, false);
7351 }
7352}
7353
7354
7355/* ----------
7356 * get_delete_query_def - Parse back a DELETE parsetree
7357 * ----------
7358 */
7359static void
7360get_delete_query_def(Query *query, deparse_context *context)
7361{
7362 StringInfo buf = context->buf;
7363 RangeTblEntry *rte;
7364
7365 /* Insert the WITH clause if given */
7366 get_with_clause(query, context);
7367
7368 /*
7369 * Start the query with DELETE FROM relname
7370 */
7371 rte = rt_fetch(query->resultRelation, query->rtable);
7372 Assert(rte->rtekind == RTE_RELATION);
7373 if (PRETTY_INDENT(context))
7374 {
7375 appendStringInfoChar(buf, ' ');
7376 context->indentLevel += PRETTYINDENT_STD;
7377 }
7378 appendStringInfo(buf, "DELETE FROM %s%s",
7379 only_marker(rte),
7380 generate_relation_name(rte->relid, NIL));
7381
7382 /* Print the relation alias, if needed */
7383 get_rte_alias(rte, query->resultRelation, false, context);
7384
7385 /* Add the USING clause if given */
7386 get_from_clause(query, " USING ", context);
7387
7388 /* Add a WHERE clause if given */
7389 if (query->jointree->quals != NULL)
7390 {
7391 appendContextKeyword(context, " WHERE ",
7392 -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
7393 get_rule_expr(query->jointree->quals, context, false);
7394 }
7395
7396 /* Add RETURNING if present */
7397 if (query->returningList)
7398 get_returning_clause(query, context);
7399}
7400
7401
7402/* ----------
7403 * get_merge_query_def - Parse back a MERGE parsetree
7404 * ----------
7405 */
7406static void
7407get_merge_query_def(Query *query, deparse_context *context)
7408{
7409 StringInfo buf = context->buf;
7410 RangeTblEntry *rte;
7411 ListCell *lc;
7412 bool haveNotMatchedBySource;
7413
7414 /* Insert the WITH clause if given */
7415 get_with_clause(query, context);
7416
7417 /*
7418 * Start the query with MERGE INTO relname
7419 */
7420 rte = rt_fetch(query->resultRelation, query->rtable);
7421 Assert(rte->rtekind == RTE_RELATION);
7422 if (PRETTY_INDENT(context))
7423 {
7424 appendStringInfoChar(buf, ' ');
7425 context->indentLevel += PRETTYINDENT_STD;
7426 }
7427 appendStringInfo(buf, "MERGE INTO %s%s",
7428 only_marker(rte),
7429 generate_relation_name(rte->relid, NIL));
7430
7431 /* Print the relation alias, if needed */
7432 get_rte_alias(rte, query->resultRelation, false, context);
7433
7434 /* Print the source relation and join clause */
7435 get_from_clause(query, " USING ", context);
7436 appendContextKeyword(context, " ON ",
7437 -PRETTYINDENT_STD, PRETTYINDENT_STD, 2);
7438 get_rule_expr(query->mergeJoinCondition, context, false);
7439
7440 /*
7441 * Test for any NOT MATCHED BY SOURCE actions. If there are none, then
7442 * any NOT MATCHED BY TARGET actions are output as "WHEN NOT MATCHED", per
7443 * SQL standard. Otherwise, we have a non-SQL-standard query, so output
7444 * "BY SOURCE" / "BY TARGET" qualifiers for all NOT MATCHED actions, to be
7445 * more explicit.
7446 */
7447 haveNotMatchedBySource = false;
7448 foreach(lc, query->mergeActionList)
7449 {
7450 MergeAction *action = lfirst_node(MergeAction, lc);
7451
7452 if (action->matchKind == MERGE_WHEN_NOT_MATCHED_BY_SOURCE)
7453 {
7454 haveNotMatchedBySource = true;
7455 break;
7456 }
7457 }
7458
7459 /* Print each merge action */
7460 foreach(lc, query->mergeActionList)
7461 {
7462 MergeAction *action = lfirst_node(MergeAction, lc);
7463
7464 appendContextKeyword(context, " WHEN ",
7465 -PRETTYINDENT_STD, PRETTYINDENT_STD, 2);
7466 switch (action->matchKind)
7467 {
7468 case MERGE_WHEN_MATCHED:
7469 appendStringInfoString(buf, "MATCHED");
7470 break;
7471 case MERGE_WHEN_NOT_MATCHED_BY_SOURCE:
7472 appendStringInfoString(buf, "NOT MATCHED BY SOURCE");
7473 break;
7474 case MERGE_WHEN_NOT_MATCHED_BY_TARGET:
7475 if (haveNotMatchedBySource)
7476 appendStringInfoString(buf, "NOT MATCHED BY TARGET");
7477 else
7478 appendStringInfoString(buf, "NOT MATCHED");
7479 break;
7480 default:
7481 elog(ERROR, "unrecognized matchKind: %d",
7482 (int) action->matchKind);
7483 }
7484
7485 if (action->qual)
7486 {
7487 appendContextKeyword(context, " AND ",
7488 -PRETTYINDENT_STD, PRETTYINDENT_STD, 3);
7489 get_rule_expr(action->qual, context, false);
7490 }
7491 appendContextKeyword(context, " THEN ",
7492 -PRETTYINDENT_STD, PRETTYINDENT_STD, 3);
7493
7494 if (action->commandType == CMD_INSERT)
7495 {
7496 /* This generally matches get_insert_query_def() */
7497 List *strippedexprs = NIL;
7498 const char *sep = "";
7499 ListCell *lc2;
7500
7501 appendStringInfoString(buf, "INSERT");
7502
7503 if (action->targetList)
7504 appendStringInfoString(buf, " (");
7505 foreach(lc2, action->targetList)
7506 {
7507 TargetEntry *tle = (TargetEntry *) lfirst(lc2);
7508
7509 Assert(!tle->resjunk);
7510
7511 appendStringInfoString(buf, sep);
7512 sep = ", ";
7513
7514 appendStringInfoString(buf,
7515 quote_identifier(get_attname(rte->relid,
7516 tle->resno,
7517 false)));
7518 strippedexprs = lappend(strippedexprs,
7519 processIndirection((Node *) tle->expr,
7520 context));
7521 }
7522 if (action->targetList)
7523 appendStringInfoChar(buf, ')');
7524
7525 if (action->override)
7526 {
7527 if (action->override == OVERRIDING_SYSTEM_VALUE)
7528 appendStringInfoString(buf, " OVERRIDING SYSTEM VALUE");
7529 else if (action->override == OVERRIDING_USER_VALUE)
7530 appendStringInfoString(buf, " OVERRIDING USER VALUE");
7531 }
7532
7533 if (strippedexprs)
7534 {
7535 appendContextKeyword(context, " VALUES (",
7536 -PRETTYINDENT_STD, PRETTYINDENT_STD, 4);
7537 get_rule_list_toplevel(strippedexprs, context, false);
7538 appendStringInfoChar(buf, ')');
7539 }
7540 else
7541 appendStringInfoString(buf, " DEFAULT VALUES");
7542 }
7543 else if (action->commandType == CMD_UPDATE)
7544 {
7545 appendStringInfoString(buf, "UPDATE SET ");
7546 get_update_query_targetlist_def(query, action->targetList,
7547 context, rte);
7548 }
7549 else if (action->commandType == CMD_DELETE)
7550 appendStringInfoString(buf, "DELETE");
7551 else if (action->commandType == CMD_NOTHING)
7552 appendStringInfoString(buf, "DO NOTHING");
7553 }
7554
7555 /* Add RETURNING if present */
7556 if (query->returningList)
7557 get_returning_clause(query, context);
7558}
7559
7560
7561/* ----------
7562 * get_utility_query_def - Parse back a UTILITY parsetree
7563 * ----------
7564 */
7565static void
7566get_utility_query_def(Query *query, deparse_context *context)
7567{
7568 StringInfo buf = context->buf;
7569
7570 if (query->utilityStmt && IsA(query->utilityStmt, NotifyStmt))
7571 {
7572 NotifyStmt *stmt = (NotifyStmt *) query->utilityStmt;
7573
7574 appendContextKeyword(context, "",
7575 0, PRETTYINDENT_STD, 1);
7576 appendStringInfo(buf, "NOTIFY %s",
7577 quote_identifier(stmt->conditionname));
7578 if (stmt->payload)
7579 {
7580 appendStringInfoString(buf, ", ");
7581 simple_quote_literal(buf, stmt->payload);
7582 }
7583 }
7584 else
7585 {
7586 /* Currently only NOTIFY utility commands can appear in rules */
7587 elog(ERROR, "unexpected utility statement type");
7588 }
7589}
7590
7591/*
7592 * Display a Var appropriately.
7593 *
7594 * In some cases (currently only when recursing into an unnamed join)
7595 * the Var's varlevelsup has to be interpreted with respect to a context
7596 * above the current one; levelsup indicates the offset.
7597 *
7598 * If istoplevel is true, the Var is at the top level of a SELECT's
7599 * targetlist, which means we need special treatment of whole-row Vars.
7600 * Instead of the normal "tab.*", we'll print "tab.*::typename", which is a
7601 * dirty hack to prevent "tab.*" from being expanded into multiple columns.
7602 * (The parser will strip the useless coercion, so no inefficiency is added in
7603 * dump and reload.) We used to print just "tab" in such cases, but that is
7604 * ambiguous and will yield the wrong result if "tab" is also a plain column
7605 * name in the query.
7606 *
7607 * Returns the attname of the Var, or NULL if the Var has no attname (because
7608 * it is a whole-row Var or a subplan output reference).
7609 */
7610static char *
7611get_variable(Var *var, int levelsup, bool istoplevel, deparse_context *context)
7612{
7613 StringInfo buf = context->buf;
7614 RangeTblEntry *rte;
7615 AttrNumber attnum;
7616 int netlevelsup;
7617 deparse_namespace *dpns;
7618 int varno;
7619 AttrNumber varattno;
7620 deparse_columns *colinfo;
7621 char *refname;
7622 char *attname;
7623 bool need_prefix;
7624
7625 /* Find appropriate nesting depth */
7626 netlevelsup = var->varlevelsup + levelsup;
7627 if (netlevelsup >= list_length(context->namespaces))
7628 elog(ERROR, "bogus varlevelsup: %d offset %d",
7629 var->varlevelsup, levelsup);
7630 dpns = (deparse_namespace *) list_nth(context->namespaces,
7631 netlevelsup);
7632
7633 /*
7634 * If we have a syntactic referent for the Var, and we're working from a
7635 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
7636 * on the semantic referent. (Forcing use of the semantic referent when
7637 * printing plan trees is a design choice that's perhaps more motivated by
7638 * backwards compatibility than anything else. But it does have the
7639 * advantage of making plans more explicit.)
7640 */
7641 if (var->varnosyn > 0 && dpns->plan == NULL)
7642 {
7643 varno = var->varnosyn;
7644 varattno = var->varattnosyn;
7645 }
7646 else
7647 {
7648 varno = var->varno;
7649 varattno = var->varattno;
7650 }
7651
7652 /*
7653 * Try to find the relevant RTE in this rtable. In a plan tree, it's
7654 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
7655 * down into the subplans, or INDEX_VAR, which is resolved similarly. Also
7656 * find the aliases previously assigned for this RTE.
7657 */
7658 if (varno >= 1 && varno <= list_length(dpns->rtable))
7659 {
7660 /*
7661 * We might have been asked to map child Vars to some parent relation.
7662 */
7663 if (context->appendparents && dpns->appendrels)
7664 {
7665 int pvarno = varno;
7666 AttrNumber pvarattno = varattno;
7667 AppendRelInfo *appinfo = dpns->appendrels[pvarno];
7668 bool found = false;
7669
7670 /* Only map up to inheritance parents, not UNION ALL appendrels */
7671 while (appinfo &&
7672 rt_fetch(appinfo->parent_relid,
7673 dpns->rtable)->rtekind == RTE_RELATION)
7674 {
7675 found = false;
7676 if (pvarattno > 0) /* system columns stay as-is */
7677 {
7678 if (pvarattno > appinfo->num_child_cols)
7679 break; /* safety check */
7680 pvarattno = appinfo->parent_colnos[pvarattno - 1];
7681 if (pvarattno == 0)
7682 break; /* Var is local to child */
7683 }
7684
7685 pvarno = appinfo->parent_relid;
7686 found = true;
7687
7688 /* If the parent is itself a child, continue up. */
7689 Assert(pvarno > 0 && pvarno <= list_length(dpns->rtable));
7690 appinfo = dpns->appendrels[pvarno];
7691 }
7692
7693 /*
7694 * If we found an ancestral rel, and that rel is included in
7695 * appendparents, print that column not the original one.
7696 */
7697 if (found && bms_is_member(pvarno, context->appendparents))
7698 {
7699 varno = pvarno;
7700 varattno = pvarattno;
7701 }
7702 }
7703
7704 rte = rt_fetch(varno, dpns->rtable);
7705
7706 /* might be returning old/new column value */
7707 if (var->varreturningtype == VAR_RETURNING_OLD)
7708 refname = dpns->ret_old_alias;
7709 else if (var->varreturningtype == VAR_RETURNING_NEW)
7710 refname = dpns->ret_new_alias;
7711 else
7712 refname = (char *) list_nth(dpns->rtable_names, varno - 1);
7713
7714 colinfo = deparse_columns_fetch(varno, dpns);
7715 attnum = varattno;
7716 }
7717 else
7718 {
7719 resolve_special_varno((Node *) var, context,
7720 get_special_variable, NULL);
7721 return NULL;
7722 }
7723
7724 /*
7725 * The planner will sometimes emit Vars referencing resjunk elements of a
7726 * subquery's target list (this is currently only possible if it chooses
7727 * to generate a "physical tlist" for a SubqueryScan or CteScan node).
7728 * Although we prefer to print subquery-referencing Vars using the
7729 * subquery's alias, that's not possible for resjunk items since they have
7730 * no alias. So in that case, drill down to the subplan and print the
7731 * contents of the referenced tlist item. This works because in a plan
7732 * tree, such Vars can only occur in a SubqueryScan or CteScan node, and
7733 * we'll have set dpns->inner_plan to reference the child plan node.
7734 */
7735 if ((rte->rtekind == RTE_SUBQUERY || rte->rtekind == RTE_CTE) &&
7736 attnum > list_length(rte->eref->colnames) &&
7737 dpns->inner_plan)
7738 {
7739 TargetEntry *tle;
7740 deparse_namespace save_dpns;
7741
7742 tle = get_tle_by_resno(dpns->inner_tlist, attnum);
7743 if (!tle)
7744 elog(ERROR, "invalid attnum %d for relation \"%s\"",
7745 attnum, rte->eref->aliasname);
7746
7747 Assert(netlevelsup == 0);
7748 push_child_plan(dpns, dpns->inner_plan, &save_dpns);
7749
7750 /*
7751 * Force parentheses because our caller probably assumed a Var is a
7752 * simple expression.
7753 */
7754 if (!IsA(tle->expr, Var))
7755 appendStringInfoChar(buf, '(');
7756 get_rule_expr((Node *) tle->expr, context, true);
7757 if (!IsA(tle->expr, Var))
7758 appendStringInfoChar(buf, ')');
7759
7760 pop_child_plan(dpns, &save_dpns);
7761 return NULL;
7762 }
7763
7764 /*
7765 * If it's an unnamed join, look at the expansion of the alias variable.
7766 * If it's a simple reference to one of the input vars, then recursively
7767 * print the name of that var instead. When it's not a simple reference,
7768 * we have to just print the unqualified join column name. (This can only
7769 * happen with "dangerous" merged columns in a JOIN USING; we took pains
7770 * previously to make the unqualified column name unique in such cases.)
7771 *
7772 * This wouldn't work in decompiling plan trees, because we don't store
7773 * joinaliasvars lists after planning; but a plan tree should never
7774 * contain a join alias variable.
7775 */
7776 if (rte->rtekind == RTE_JOIN && rte->alias == NULL)
7777 {
7778 if (rte->joinaliasvars == NIL)
7779 elog(ERROR, "cannot decompile join alias var in plan tree");
7780 if (attnum > 0)
7781 {
7782 Var *aliasvar;
7783
7784 aliasvar = (Var *) list_nth(rte->joinaliasvars, attnum - 1);
7785 /* we intentionally don't strip implicit coercions here */
7786 if (aliasvar && IsA(aliasvar, Var))
7787 {
7788 return get_variable(aliasvar, var->varlevelsup + levelsup,
7789 istoplevel, context);
7790 }
7791 }
7792
7793 /*
7794 * Unnamed join has no refname. (Note: since it's unnamed, there is
7795 * no way the user could have referenced it to create a whole-row Var
7796 * for it. So we don't have to cover that case below.)
7797 */
7798 Assert(refname == NULL);
7799 }
7800
7801 if (attnum == InvalidAttrNumber)
7802 attname = NULL;
7803 else if (attnum > 0)
7804 {
7805 /* Get column name to use from the colinfo struct */
7806 if (attnum > colinfo->num_cols)
7807 elog(ERROR, "invalid attnum %d for relation \"%s\"",
7808 attnum, rte->eref->aliasname);
7809 attname = colinfo->colnames[attnum - 1];
7810
7811 /*
7812 * If we find a Var referencing a dropped column, it seems better to
7813 * print something (anything) than to fail. In general this should
7814 * not happen, but it used to be possible for some cases involving
7815 * functions returning named composite types, and perhaps there are
7816 * still bugs out there.
7817 */
7818 if (attname == NULL)
7819 attname = "?dropped?column?";
7820 }
7821 else
7822 {
7823 /* System column - name is fixed, get it from the catalog */
7824 attname = get_rte_attribute_name(rte, attnum);
7825 }
7826
7827 need_prefix = (context->varprefix || attname == NULL ||
7828 var->varreturningtype != VAR_RETURNING_DEFAULT);
7829
7830 /*
7831 * If we're considering a plain Var in an ORDER BY (but not GROUP BY)
7832 * clause, we may need to add a table-name prefix to prevent
7833 * findTargetlistEntrySQL92 from misinterpreting the name as an
7834 * output-column name. To avoid cluttering the output with unnecessary
7835 * prefixes, do so only if there is a name match to a SELECT tlist item
7836 * that is different from the Var.
7837 */
7838 if (context->varInOrderBy && !context->inGroupBy && !need_prefix)
7839 {
7840 int colno = 0;
7841
7842 foreach_node(TargetEntry, tle, context->targetList)
7843 {
7844 char *colname;
7845
7846 if (tle->resjunk)
7847 continue; /* ignore junk entries */
7848 colno++;
7849
7850 /* This must match colname-choosing logic in get_target_list() */
7851 if (context->resultDesc && colno <= context->resultDesc->natts)
7852 colname = NameStr(TupleDescAttr(context->resultDesc,
7853 colno - 1)->attname);
7854 else
7855 colname = tle->resname;
7856
7857 if (colname && strcmp(colname, attname) == 0 &&
7858 !equal(var, tle->expr))
7859 {
7860 need_prefix = true;
7861 break;
7862 }
7863 }
7864 }
7865
7866 if (refname && need_prefix)
7867 {
7868 appendStringInfoString(buf, quote_identifier(refname));
7869 appendStringInfoChar(buf, '.');
7870 }
7871 if (attname)
7872 appendStringInfoString(buf, quote_identifier(attname));
7873 else
7874 {
7875 appendStringInfoChar(buf, '*');
7876 if (istoplevel)
7877 appendStringInfo(buf, "::%s",
7878 format_type_with_typemod(var->vartype,
7879 var->vartypmod));
7880 }
7881
7882 return attname;
7883}
7884
7885/*
7886 * Deparse a Var which references OUTER_VAR, INNER_VAR, or INDEX_VAR. This
7887 * routine is actually a callback for resolve_special_varno, which handles
7888 * finding the correct TargetEntry. We get the expression contained in that
7889 * TargetEntry and just need to deparse it, a job we can throw back on
7890 * get_rule_expr.
7891 */
7892static void
7893get_special_variable(Node *node, deparse_context *context, void *callback_arg)
7894{
7895 StringInfo buf = context->buf;
7896
7897 /*
7898 * For a non-Var referent, force parentheses because our caller probably
7899 * assumed a Var is a simple expression.
7900 */
7901 if (!IsA(node, Var))
7902 appendStringInfoChar(buf, '(');
7903 get_rule_expr(node, context, true);
7904 if (!IsA(node, Var))
7905 appendStringInfoChar(buf, ')');
7906}
7907
7908/*
7909 * Chase through plan references to special varnos (OUTER_VAR, INNER_VAR,
7910 * INDEX_VAR) until we find a real Var or some kind of non-Var node; then,
7911 * invoke the callback provided.
7912 */
7913static void
7914resolve_special_varno(Node *node, deparse_context *context,
7915 rsv_callback callback, void *callback_arg)
7916{
7917 Var *var;
7918 deparse_namespace *dpns;
7919
7920 /* This function is recursive, so let's be paranoid. */
7921 check_stack_depth();
7922
7923 /* If it's not a Var, invoke the callback. */
7924 if (!IsA(node, Var))
7925 {
7926 (*callback) (node, context, callback_arg);
7927 return;
7928 }
7929
7930 /* Find appropriate nesting depth */
7931 var = (Var *) node;
7932 dpns = (deparse_namespace *) list_nth(context->namespaces,
7933 var->varlevelsup);
7934
7935 /*
7936 * If varno is special, recurse. (Don't worry about varnosyn; if we're
7937 * here, we already decided not to use that.)
7938 */
7939 if (var->varno == OUTER_VAR && dpns->outer_tlist)
7940 {
7941 TargetEntry *tle;
7942 deparse_namespace save_dpns;
7943 Bitmapset *save_appendparents;
7944
7945 tle = get_tle_by_resno(dpns->outer_tlist, var->varattno);
7946 if (!tle)
7947 elog(ERROR, "bogus varattno for OUTER_VAR var: %d", var->varattno);
7948
7949 /*
7950 * If we're descending to the first child of an Append or MergeAppend,
7951 * update appendparents. This will affect deparsing of all Vars
7952 * appearing within the eventually-resolved subexpression.
7953 */
7954 save_appendparents = context->appendparents;
7955
7956 if (IsA(dpns->plan, Append))
7957 context->appendparents = bms_union(context->appendparents,
7958 ((Append *) dpns->plan)->apprelids);
7959 else if (IsA(dpns->plan, MergeAppend))
7960 context->appendparents = bms_union(context->appendparents,
7961 ((MergeAppend *) dpns->plan)->apprelids);
7962
7963 push_child_plan(dpns, dpns->outer_plan, &save_dpns);
7964 resolve_special_varno((Node *) tle->expr, context,
7965 callback, callback_arg);
7966 pop_child_plan(dpns, &save_dpns);
7967 context->appendparents = save_appendparents;
7968 return;
7969 }
7970 else if (var->varno == INNER_VAR && dpns->inner_tlist)
7971 {
7972 TargetEntry *tle;
7973 deparse_namespace save_dpns;
7974
7975 tle = get_tle_by_resno(dpns->inner_tlist, var->varattno);
7976 if (!tle)
7977 elog(ERROR, "bogus varattno for INNER_VAR var: %d", var->varattno);
7978
7979 push_child_plan(dpns, dpns->inner_plan, &save_dpns);
7980 resolve_special_varno((Node *) tle->expr, context,
7981 callback, callback_arg);
7982 pop_child_plan(dpns, &save_dpns);
7983 return;
7984 }
7985 else if (var->varno == INDEX_VAR && dpns->index_tlist)
7986 {
7987 TargetEntry *tle;
7988
7989 tle = get_tle_by_resno(dpns->index_tlist, var->varattno);
7990 if (!tle)
7991 elog(ERROR, "bogus varattno for INDEX_VAR var: %d", var->varattno);
7992
7993 resolve_special_varno((Node *) tle->expr, context,
7994 callback, callback_arg);
7995 return;
7996 }
7997 else if (var->varno < 1 || var->varno > list_length(dpns->rtable))
7998 elog(ERROR, "bogus varno: %d", var->varno);
7999
8000 /* Not special. Just invoke the callback. */
8001 (*callback) (node, context, callback_arg);
8002}
8003
8004/*
8005 * Get the name of a field of an expression of composite type. The
8006 * expression is usually a Var, but we handle other cases too.
8007 *
8008 * levelsup is an extra offset to interpret the Var's varlevelsup correctly.
8009 *
8010 * This is fairly straightforward when the expression has a named composite
8011 * type; we need only look up the type in the catalogs. However, the type
8012 * could also be RECORD. Since no actual table or view column is allowed to
8013 * have type RECORD, a Var of type RECORD must refer to a JOIN or FUNCTION RTE
8014 * or to a subquery output. We drill down to find the ultimate defining
8015 * expression and attempt to infer the field name from it. We ereport if we
8016 * can't determine the name.
8017 *
8018 * Similarly, a PARAM of type RECORD has to refer to some expression of
8019 * a determinable composite type.
8020 */
8021static const char *
8022get_name_for_var_field(Var *var, int fieldno,
8023 int levelsup, deparse_context *context)
8024{
8025 RangeTblEntry *rte;
8026 AttrNumber attnum;
8027 int netlevelsup;
8028 deparse_namespace *dpns;
8029 int varno;
8030 AttrNumber varattno;
8031 TupleDesc tupleDesc;
8032 Node *expr;
8033
8034 /*
8035 * If it's a RowExpr that was expanded from a whole-row Var, use the
8036 * column names attached to it. (We could let get_expr_result_tupdesc()
8037 * handle this, but it's much cheaper to just pull out the name we need.)
8038 */
8039 if (IsA(var, RowExpr))
8040 {
8041 RowExpr *r = (RowExpr *) var;
8042
8043 if (fieldno > 0 && fieldno <= list_length(r->colnames))
8044 return strVal(list_nth(r->colnames, fieldno - 1));
8045 }
8046
8047 /*
8048 * If it's a Param of type RECORD, try to find what the Param refers to.
8049 */
8050 if (IsA(var, Param))
8051 {
8052 Param *param = (Param *) var;
8053 ListCell *ancestor_cell;
8054
8055 expr = find_param_referent(param, context, &dpns, &ancestor_cell);
8056 if (expr)
8057 {
8058 /* Found a match, so recurse to decipher the field name */
8059 deparse_namespace save_dpns;
8060 const char *result;
8061
8062 push_ancestor_plan(dpns, ancestor_cell, &save_dpns);
8063 result = get_name_for_var_field((Var *) expr, fieldno,
8064 0, context);
8065 pop_ancestor_plan(dpns, &save_dpns);
8066 return result;
8067 }
8068 }
8069
8070 /*
8071 * If it's a Var of type RECORD, we have to find what the Var refers to;
8072 * if not, we can use get_expr_result_tupdesc().
8073 */
8074 if (!IsA(var, Var) ||
8075 var->vartype != RECORDOID)
8076 {
8077 tupleDesc = get_expr_result_tupdesc((Node *) var, false);
8078 /* Got the tupdesc, so we can extract the field name */
8079 Assert(fieldno >= 1 && fieldno <= tupleDesc->natts);
8080 return NameStr(TupleDescAttr(tupleDesc, fieldno - 1)->attname);
8081 }
8082
8083 /* Find appropriate nesting depth */
8084 netlevelsup = var->varlevelsup + levelsup;
8085 if (netlevelsup >= list_length(context->namespaces))
8086 elog(ERROR, "bogus varlevelsup: %d offset %d",
8087 var->varlevelsup, levelsup);
8088 dpns = (deparse_namespace *) list_nth(context->namespaces,
8089 netlevelsup);
8090
8091 /*
8092 * If we have a syntactic referent for the Var, and we're working from a
8093 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
8094 * on the semantic referent. (See comments in get_variable().)
8095 */
8096 if (var->varnosyn > 0 && dpns->plan == NULL)
8097 {
8098 varno = var->varnosyn;
8099 varattno = var->varattnosyn;
8100 }
8101 else
8102 {
8103 varno = var->varno;
8104 varattno = var->varattno;
8105 }
8106
8107 /*
8108 * Try to find the relevant RTE in this rtable. In a plan tree, it's
8109 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
8110 * down into the subplans, or INDEX_VAR, which is resolved similarly.
8111 *
8112 * Note: unlike get_variable and resolve_special_varno, we need not worry
8113 * about inheritance mapping: a child Var should have the same datatype as
8114 * its parent, and here we're really only interested in the Var's type.
8115 */
8116 if (varno >= 1 && varno <= list_length(dpns->rtable))
8117 {
8118 rte = rt_fetch(varno, dpns->rtable);
8119 attnum = varattno;
8120 }
8121 else if (varno == OUTER_VAR && dpns->outer_tlist)
8122 {
8123 TargetEntry *tle;
8124 deparse_namespace save_dpns;
8125 const char *result;
8126
8127 tle = get_tle_by_resno(dpns->outer_tlist, varattno);
8128 if (!tle)
8129 elog(ERROR, "bogus varattno for OUTER_VAR var: %d", varattno);
8130
8131 Assert(netlevelsup == 0);
8132 push_child_plan(dpns, dpns->outer_plan, &save_dpns);
8133
8134 result = get_name_for_var_field((Var *) tle->expr, fieldno,
8135 levelsup, context);
8136
8137 pop_child_plan(dpns, &save_dpns);
8138 return result;
8139 }
8140 else if (varno == INNER_VAR && dpns->inner_tlist)
8141 {
8142 TargetEntry *tle;
8143 deparse_namespace save_dpns;
8144 const char *result;
8145
8146 tle = get_tle_by_resno(dpns->inner_tlist, varattno);
8147 if (!tle)
8148 elog(ERROR, "bogus varattno for INNER_VAR var: %d", varattno);
8149
8150 Assert(netlevelsup == 0);
8151 push_child_plan(dpns, dpns->inner_plan, &save_dpns);
8152
8153 result = get_name_for_var_field((Var *) tle->expr, fieldno,
8154 levelsup, context);
8155
8156 pop_child_plan(dpns, &save_dpns);
8157 return result;
8158 }
8159 else if (varno == INDEX_VAR && dpns->index_tlist)
8160 {
8161 TargetEntry *tle;
8162 const char *result;
8163
8164 tle = get_tle_by_resno(dpns->index_tlist, varattno);
8165 if (!tle)
8166 elog(ERROR, "bogus varattno for INDEX_VAR var: %d", varattno);
8167
8168 Assert(netlevelsup == 0);
8169
8170 result = get_name_for_var_field((Var *) tle->expr, fieldno,
8171 levelsup, context);
8172
8173 return result;
8174 }
8175 else
8176 {
8177 elog(ERROR, "bogus varno: %d", varno);
8178 return NULL; /* keep compiler quiet */
8179 }
8180
8181 if (attnum == InvalidAttrNumber)
8182 {
8183 /* Var is whole-row reference to RTE, so select the right field */
8184 return get_rte_attribute_name(rte, fieldno);
8185 }
8186
8187 /*
8188 * This part has essentially the same logic as the parser's
8189 * expandRecordVariable() function, but we are dealing with a different
8190 * representation of the input context, and we only need one field name
8191 * not a TupleDesc. Also, we need special cases for finding subquery and
8192 * CTE subplans when deparsing Plan trees.
8193 */
8194 expr = (Node *) var; /* default if we can't drill down */
8195
8196 switch (rte->rtekind)
8197 {
8198 case RTE_RELATION:
8199 case RTE_VALUES:
8200 case RTE_NAMEDTUPLESTORE:
8201 case RTE_RESULT:
8202
8203 /*
8204 * This case should not occur: a column of a table, values list,
8205 * or ENR shouldn't have type RECORD. Fall through and fail (most
8206 * likely) at the bottom.
8207 */
8208 break;
8209 case RTE_SUBQUERY:
8210 /* Subselect-in-FROM: examine sub-select's output expr */
8211 {
8212 if (rte->subquery)
8213 {
8214 TargetEntry *ste = get_tle_by_resno(rte->subquery->targetList,
8215 attnum);
8216
8217 if (ste == NULL || ste->resjunk)
8218 elog(ERROR, "subquery %s does not have attribute %d",
8219 rte->eref->aliasname, attnum);
8220 expr = (Node *) ste->expr;
8221 if (IsA(expr, Var))
8222 {
8223 /*
8224 * Recurse into the sub-select to see what its Var
8225 * refers to. We have to build an additional level of
8226 * namespace to keep in step with varlevelsup in the
8227 * subselect; furthermore, the subquery RTE might be
8228 * from an outer query level, in which case the
8229 * namespace for the subselect must have that outer
8230 * level as parent namespace.
8231 */
8232 List *save_nslist = context->namespaces;
8233 List *parent_namespaces;
8234 deparse_namespace mydpns;
8235 const char *result;
8236
8237 parent_namespaces = list_copy_tail(context->namespaces,
8238 netlevelsup);
8239
8240 set_deparse_for_query(&mydpns, rte->subquery,
8241 parent_namespaces);
8242
8243 context->namespaces = lcons(&mydpns, parent_namespaces);
8244
8245 result = get_name_for_var_field((Var *) expr, fieldno,
8246 0, context);
8247
8248 context->namespaces = save_nslist;
8249
8250 return result;
8251 }
8252 /* else fall through to inspect the expression */
8253 }
8254 else
8255 {
8256 /*
8257 * We're deparsing a Plan tree so we don't have complete
8258 * RTE entries (in particular, rte->subquery is NULL). But
8259 * the only place we'd normally see a Var directly
8260 * referencing a SUBQUERY RTE is in a SubqueryScan plan
8261 * node, and we can look into the child plan's tlist
8262 * instead. An exception occurs if the subquery was
8263 * proven empty and optimized away: then we'd find such a
8264 * Var in a childless Result node, and there's nothing in
8265 * the plan tree that would let us figure out what it had
8266 * originally referenced. In that case, fall back on
8267 * printing "fN", analogously to the default column names
8268 * for RowExprs.
8269 */
8270 TargetEntry *tle;
8271 deparse_namespace save_dpns;
8272 const char *result;
8273
8274 if (!dpns->inner_plan)
8275 {
8276 char *dummy_name = palloc(32);
8277
8278 Assert(dpns->plan && IsA(dpns->plan, Result));
8279 snprintf(dummy_name, 32, "f%d", fieldno);
8280 return dummy_name;
8281 }
8282 Assert(dpns->plan && IsA(dpns->plan, SubqueryScan));
8283
8284 tle = get_tle_by_resno(dpns->inner_tlist, attnum);
8285 if (!tle)
8286 elog(ERROR, "bogus varattno for subquery var: %d",
8287 attnum);
8288 Assert(netlevelsup == 0);
8289 push_child_plan(dpns, dpns->inner_plan, &save_dpns);
8290
8291 result = get_name_for_var_field((Var *) tle->expr, fieldno,
8292 levelsup, context);
8293
8294 pop_child_plan(dpns, &save_dpns);
8295 return result;
8296 }
8297 }
8298 break;
8299 case RTE_JOIN:
8300 /* Join RTE --- recursively inspect the alias variable */
8301 if (rte->joinaliasvars == NIL)
8302 elog(ERROR, "cannot decompile join alias var in plan tree");
8303 Assert(attnum > 0 && attnum <= list_length(rte->joinaliasvars));
8304 expr = (Node *) list_nth(rte->joinaliasvars, attnum - 1);
8305 Assert(expr != NULL);
8306 /* we intentionally don't strip implicit coercions here */
8307 if (IsA(expr, Var))
8308 return get_name_for_var_field((Var *) expr, fieldno,
8309 var->varlevelsup + levelsup,
8310 context);
8311 /* else fall through to inspect the expression */
8312 break;
8313 case RTE_FUNCTION:
8314 case RTE_TABLEFUNC:
8315
8316 /*
8317 * We couldn't get here unless a function is declared with one of
8318 * its result columns as RECORD, which is not allowed.
8319 */
8320 break;
8321 case RTE_CTE:
8322 /* CTE reference: examine subquery's output expr */
8323 {
8324 CommonTableExpr *cte = NULL;
8325 Index ctelevelsup;
8326 ListCell *lc;
8327
8328 /*
8329 * Try to find the referenced CTE using the namespace stack.
8330 */
8331 ctelevelsup = rte->ctelevelsup + netlevelsup;
8332 if (ctelevelsup >= list_length(context->namespaces))
8333 lc = NULL;
8334 else
8335 {
8336 deparse_namespace *ctedpns;
8337
8338 ctedpns = (deparse_namespace *)
8339 list_nth(context->namespaces, ctelevelsup);
8340 foreach(lc, ctedpns->ctes)
8341 {
8342 cte = (CommonTableExpr *) lfirst(lc);
8343 if (strcmp(cte->ctename, rte->ctename) == 0)
8344 break;
8345 }
8346 }
8347 if (lc != NULL)
8348 {
8349 Query *ctequery = (Query *) cte->ctequery;
8350 TargetEntry *ste = get_tle_by_resno(GetCTETargetList(cte),
8351 attnum);
8352
8353 if (ste == NULL || ste->resjunk)
8354 elog(ERROR, "CTE %s does not have attribute %d",
8355 rte->eref->aliasname, attnum);
8356 expr = (Node *) ste->expr;
8357 if (IsA(expr, Var))
8358 {
8359 /*
8360 * Recurse into the CTE to see what its Var refers to.
8361 * We have to build an additional level of namespace
8362 * to keep in step with varlevelsup in the CTE;
8363 * furthermore it could be an outer CTE (compare
8364 * SUBQUERY case above).
8365 */
8366 List *save_nslist = context->namespaces;
8367 List *parent_namespaces;
8368 deparse_namespace mydpns;
8369 const char *result;
8370
8371 parent_namespaces = list_copy_tail(context->namespaces,
8372 ctelevelsup);
8373
8374 set_deparse_for_query(&mydpns, ctequery,
8375 parent_namespaces);
8376
8377 context->namespaces = lcons(&mydpns, parent_namespaces);
8378
8379 result = get_name_for_var_field((Var *) expr, fieldno,
8380 0, context);
8381
8382 context->namespaces = save_nslist;
8383
8384 return result;
8385 }
8386 /* else fall through to inspect the expression */
8387 }
8388 else
8389 {
8390 /*
8391 * We're deparsing a Plan tree so we don't have a CTE
8392 * list. But the only places we'd normally see a Var
8393 * directly referencing a CTE RTE are in CteScan or
8394 * WorkTableScan plan nodes. For those cases,
8395 * set_deparse_plan arranged for dpns->inner_plan to be
8396 * the plan node that emits the CTE or RecursiveUnion
8397 * result, and we can look at its tlist instead. As
8398 * above, this can fail if the CTE has been proven empty,
8399 * in which case fall back to "fN".
8400 */
8401 TargetEntry *tle;
8402 deparse_namespace save_dpns;
8403 const char *result;
8404
8405 if (!dpns->inner_plan)
8406 {
8407 char *dummy_name = palloc(32);
8408
8409 Assert(dpns->plan && IsA(dpns->plan, Result));
8410 snprintf(dummy_name, 32, "f%d", fieldno);
8411 return dummy_name;
8412 }
8413 Assert(dpns->plan && (IsA(dpns->plan, CteScan) ||
8414 IsA(dpns->plan, WorkTableScan)));
8415
8416 tle = get_tle_by_resno(dpns->inner_tlist, attnum);
8417 if (!tle)
8418 elog(ERROR, "bogus varattno for subquery var: %d",
8419 attnum);
8420 Assert(netlevelsup == 0);
8421 push_child_plan(dpns, dpns->inner_plan, &save_dpns);
8422
8423 result = get_name_for_var_field((Var *) tle->expr, fieldno,
8424 levelsup, context);
8425
8426 pop_child_plan(dpns, &save_dpns);
8427 return result;
8428 }
8429 }
8430 break;
8431 case RTE_GROUP:
8432
8433 /*
8434 * We couldn't get here: any Vars that reference the RTE_GROUP RTE
8435 * should have been replaced with the underlying grouping
8436 * expressions.
8437 */
8438 break;
8439 }
8440
8441 /*
8442 * We now have an expression we can't expand any more, so see if
8443 * get_expr_result_tupdesc() can do anything with it.
8444 */
8445 tupleDesc = get_expr_result_tupdesc(expr, false);
8446 /* Got the tupdesc, so we can extract the field name */
8447 Assert(fieldno >= 1 && fieldno <= tupleDesc->natts);
8448 return NameStr(TupleDescAttr(tupleDesc, fieldno - 1)->attname);
8449}
8450
8451/*
8452 * Try to find the referenced expression for a PARAM_EXEC Param that might
8453 * reference a parameter supplied by an upper NestLoop or SubPlan plan node.
8454 *
8455 * If successful, return the expression and set *dpns_p and *ancestor_cell_p
8456 * appropriately for calling push_ancestor_plan(). If no referent can be
8457 * found, return NULL.
8458 */
8459static Node *
8460find_param_referent(Param *param, deparse_context *context,
8461 deparse_namespace **dpns_p, ListCell **ancestor_cell_p)
8462{
8463 /* Initialize output parameters to prevent compiler warnings */
8464 *dpns_p = NULL;
8465 *ancestor_cell_p = NULL;
8466
8467 /*
8468 * If it's a PARAM_EXEC parameter, look for a matching NestLoopParam or
8469 * SubPlan argument. This will necessarily be in some ancestor of the
8470 * current expression's Plan node.
8471 */
8472 if (param->paramkind == PARAM_EXEC)
8473 {
8474 deparse_namespace *dpns;
8475 Plan *child_plan;
8476 ListCell *lc;
8477
8478 dpns = (deparse_namespace *) linitial(context->namespaces);
8479 child_plan = dpns->plan;
8480
8481 foreach(lc, dpns->ancestors)
8482 {
8483 Node *ancestor = (Node *) lfirst(lc);
8484 ListCell *lc2;
8485
8486 /*
8487 * NestLoops transmit params to their inner child only.
8488 */
8489 if (IsA(ancestor, NestLoop) &&
8490 child_plan == innerPlan(ancestor))
8491 {
8492 NestLoop *nl = (NestLoop *) ancestor;
8493
8494 foreach(lc2, nl->nestParams)
8495 {
8496 NestLoopParam *nlp = (NestLoopParam *) lfirst(lc2);
8497
8498 if (nlp->paramno == param->paramid)
8499 {
8500 /* Found a match, so return it */
8501 *dpns_p = dpns;
8502 *ancestor_cell_p = lc;
8503 return (Node *) nlp->paramval;
8504 }
8505 }
8506 }
8507
8508 /*
8509 * If ancestor is a SubPlan, check the arguments it provides.
8510 */
8511 if (IsA(ancestor, SubPlan))
8512 {
8513 SubPlan *subplan = (SubPlan *) ancestor;
8514 ListCell *lc3;
8515 ListCell *lc4;
8516
8517 forboth(lc3, subplan->parParam, lc4, subplan->args)
8518 {
8519 int paramid = lfirst_int(lc3);
8520 Node *arg = (Node *) lfirst(lc4);
8521
8522 if (paramid == param->paramid)
8523 {
8524 /*
8525 * Found a match, so return it. But, since Vars in
8526 * the arg are to be evaluated in the surrounding
8527 * context, we have to point to the next ancestor item
8528 * that is *not* a SubPlan.
8529 */
8530 ListCell *rest;
8531
8532 for_each_cell(rest, dpns->ancestors,
8533 lnext(dpns->ancestors, lc))
8534 {
8535 Node *ancestor2 = (Node *) lfirst(rest);
8536
8537 if (!IsA(ancestor2, SubPlan))
8538 {
8539 *dpns_p = dpns;
8540 *ancestor_cell_p = rest;
8541 return arg;
8542 }
8543 }
8544 elog(ERROR, "SubPlan cannot be outermost ancestor");
8545 }
8546 }
8547
8548 /* SubPlan isn't a kind of Plan, so skip the rest */
8549 continue;
8550 }
8551
8552 /*
8553 * We need not consider the ancestor's initPlan list, since
8554 * initplans never have any parParams.
8555 */
8556
8557 /* No luck, crawl up to next ancestor */
8558 child_plan = (Plan *) ancestor;
8559 }
8560 }
8561
8562 /* No referent found */
8563 return NULL;
8564}
8565
8566/*
8567 * Try to find a subplan/initplan that emits the value for a PARAM_EXEC Param.
8568 *
8569 * If successful, return the generating subplan/initplan and set *column_p
8570 * to the subplan's 0-based output column number.
8571 * Otherwise, return NULL.
8572 */
8573static SubPlan *
8574find_param_generator(Param *param, deparse_context *context, int *column_p)
8575{
8576 /* Initialize output parameter to prevent compiler warnings */
8577 *column_p = 0;
8578
8579 /*
8580 * If it's a PARAM_EXEC parameter, search the current plan node as well as
8581 * ancestor nodes looking for a subplan or initplan that emits the value
8582 * for the Param. It could appear in the setParams of an initplan or
8583 * MULTIEXPR_SUBLINK subplan, or in the paramIds of an ancestral SubPlan.
8584 */
8585 if (param->paramkind == PARAM_EXEC)
8586 {
8587 SubPlan *result;
8588 deparse_namespace *dpns;
8589 ListCell *lc;
8590
8591 dpns = (deparse_namespace *) linitial(context->namespaces);
8592
8593 /* First check the innermost plan node's initplans */
8594 result = find_param_generator_initplan(param, dpns->plan, column_p);
8595 if (result)
8596 return result;
8597
8598 /*
8599 * The plan's targetlist might contain MULTIEXPR_SUBLINK SubPlans,
8600 * which can be referenced by Params elsewhere in the targetlist.
8601 * (Such Params should always be in the same targetlist, so there's no
8602 * need to do this work at upper plan nodes.)
8603 */
8604 foreach_node(TargetEntry, tle, dpns->plan->targetlist)
8605 {
8606 if (tle->expr && IsA(tle->expr, SubPlan))
8607 {
8608 SubPlan *subplan = (SubPlan *) tle->expr;
8609
8610 if (subplan->subLinkType == MULTIEXPR_SUBLINK)
8611 {
8612 foreach_int(paramid, subplan->setParam)
8613 {
8614 if (paramid == param->paramid)
8615 {
8616 /* Found a match, so return it. */
8617 *column_p = foreach_current_index(paramid);
8618 return subplan;
8619 }
8620 }
8621 }
8622 }
8623 }
8624
8625 /* No luck, so check the ancestor nodes */
8626 foreach(lc, dpns->ancestors)
8627 {
8628 Node *ancestor = (Node *) lfirst(lc);
8629
8630 /*
8631 * If ancestor is a SubPlan, check the paramIds it provides.
8632 */
8633 if (IsA(ancestor, SubPlan))
8634 {
8635 SubPlan *subplan = (SubPlan *) ancestor;
8636
8637 foreach_int(paramid, subplan->paramIds)
8638 {
8639 if (paramid == param->paramid)
8640 {
8641 /* Found a match, so return it. */
8642 *column_p = foreach_current_index(paramid);
8643 return subplan;
8644 }
8645 }
8646
8647 /* SubPlan isn't a kind of Plan, so skip the rest */
8648 continue;
8649 }
8650
8651 /*
8652 * Otherwise, it's some kind of Plan node, so check its initplans.
8653 */
8654 result = find_param_generator_initplan(param, (Plan *) ancestor,
8655 column_p);
8656 if (result)
8657 return result;
8658
8659 /* No luck, crawl up to next ancestor */
8660 }
8661 }
8662
8663 /* No generator found */
8664 return NULL;
8665}
8666
8667/*
8668 * Subroutine for find_param_generator: search one Plan node's initplans
8669 */
8670static SubPlan *
8671find_param_generator_initplan(Param *param, Plan *plan, int *column_p)
8672{
8673 foreach_node(SubPlan, subplan, plan->initPlan)
8674 {
8675 foreach_int(paramid, subplan->setParam)
8676 {
8677 if (paramid == param->paramid)
8678 {
8679 /* Found a match, so return it. */
8680 *column_p = foreach_current_index(paramid);
8681 return subplan;
8682 }
8683 }
8684 }
8685 return NULL;
8686}
8687
8688/*
8689 * Display a Param appropriately.
8690 */
8691static void
8692get_parameter(Param *param, deparse_context *context)
8693{
8694 Node *expr;
8695 deparse_namespace *dpns;
8696 ListCell *ancestor_cell;
8697 SubPlan *subplan;
8698 int column;
8699
8700 /*
8701 * If it's a PARAM_EXEC parameter, try to locate the expression from which
8702 * the parameter was computed. This stanza handles only cases in which
8703 * the Param represents an input to the subplan we are currently in.
8704 */
8705 expr = find_param_referent(param, context, &dpns, &ancestor_cell);
8706 if (expr)
8707 {
8708 /* Found a match, so print it */
8709 deparse_namespace save_dpns;
8710 bool save_varprefix;
8711 bool need_paren;
8712
8713 /* Switch attention to the ancestor plan node */
8714 push_ancestor_plan(dpns, ancestor_cell, &save_dpns);
8715
8716 /*
8717 * Force prefixing of Vars, since they won't belong to the relation
8718 * being scanned in the original plan node.
8719 */
8720 save_varprefix = context->varprefix;
8721 context->varprefix = true;
8722
8723 /*
8724 * A Param's expansion is typically a Var, Aggref, GroupingFunc, or
8725 * upper-level Param, which wouldn't need extra parentheses.
8726 * Otherwise, insert parens to ensure the expression looks atomic.
8727 */
8728 need_paren = !(IsA(expr, Var) ||
8729 IsA(expr, Aggref) ||
8730 IsA(expr, GroupingFunc) ||
8731 IsA(expr, Param));
8732 if (need_paren)
8733 appendStringInfoChar(context->buf, '(');
8734
8735 get_rule_expr(expr, context, false);
8736
8737 if (need_paren)
8738 appendStringInfoChar(context->buf, ')');
8739
8740 context->varprefix = save_varprefix;
8741
8742 pop_ancestor_plan(dpns, &save_dpns);
8743
8744 return;
8745 }
8746
8747 /*
8748 * Alternatively, maybe it's a subplan output, which we print as a
8749 * reference to the subplan. (We could drill down into the subplan and
8750 * print the relevant targetlist expression, but that has been deemed too
8751 * confusing since it would violate normal SQL scope rules. Also, we're
8752 * relying on this reference to show that the testexpr containing the
8753 * Param has anything to do with that subplan at all.)
8754 */
8755 subplan = find_param_generator(param, context, &column);
8756 if (subplan)
8757 {
8758 const char *nameprefix;
8759
8760 if (subplan->isInitPlan)
8761 nameprefix = "InitPlan ";
8762 else
8763 nameprefix = "SubPlan ";
8764
8765 appendStringInfo(context->buf, "(%s%s%s).col%d",
8766 subplan->useHashTable ? "hashed " : "",
8767 nameprefix,
8768 subplan->plan_name, column + 1);
8769
8770 return;
8771 }
8772
8773 /*
8774 * If it's an external parameter, see if the outermost namespace provides
8775 * function argument names.
8776 */
8777 if (param->paramkind == PARAM_EXTERN && context->namespaces != NIL)
8778 {
8779 dpns = llast(context->namespaces);
8780 if (dpns->argnames &&
8781 param->paramid > 0 &&
8782 param->paramid <= dpns->numargs)
8783 {
8784 char *argname = dpns->argnames[param->paramid - 1];
8785
8786 if (argname)
8787 {
8788 bool should_qualify = false;
8789 ListCell *lc;
8790
8791 /*
8792 * Qualify the parameter name if there are any other deparse
8793 * namespaces with range tables. This avoids qualifying in
8794 * trivial cases like "RETURN a + b", but makes it safe in all
8795 * other cases.
8796 */
8797 foreach(lc, context->namespaces)
8798 {
8799 deparse_namespace *depns = lfirst(lc);
8800
8801 if (depns->rtable_names != NIL)
8802 {
8803 should_qualify = true;
8804 break;
8805 }
8806 }
8807 if (should_qualify)
8808 {
8809 appendStringInfoString(context->buf, quote_identifier(dpns->funcname));
8810 appendStringInfoChar(context->buf, '.');
8811 }
8812
8813 appendStringInfoString(context->buf, quote_identifier(argname));
8814 return;
8815 }
8816 }
8817 }
8818
8819 /*
8820 * Not PARAM_EXEC, or couldn't find referent: just print $N.
8821 *
8822 * It's a bug if we get here for anything except PARAM_EXTERN Params, but
8823 * in production builds printing $N seems more useful than failing.
8824 */
8825 Assert(param->paramkind == PARAM_EXTERN);
8826
8827 appendStringInfo(context->buf, "$%d", param->paramid);
8828}
8829
8830/*
8831 * get_simple_binary_op_name
8832 *
8833 * helper function for isSimpleNode
8834 * will return single char binary operator name, or NULL if it's not
8835 */
8836static const char *
8837get_simple_binary_op_name(OpExpr *expr)
8838{
8839 List *args = expr->args;
8840
8841 if (list_length(args) == 2)
8842 {
8843 /* binary operator */
8844 Node *arg1 = (Node *) linitial(args);
8845 Node *arg2 = (Node *) lsecond(args);
8846 const char *op;
8847
8848 op = generate_operator_name(expr->opno, exprType(arg1), exprType(arg2));
8849 if (strlen(op) == 1)
8850 return op;
8851 }
8852 return NULL;
8853}
8854
8855
8856/*
8857 * isSimpleNode - check if given node is simple (doesn't need parenthesizing)
8858 *
8859 * true : simple in the context of parent node's type
8860 * false : not simple
8861 */
8862static bool
8863isSimpleNode(Node *node, Node *parentNode, int prettyFlags)
8864{
8865 if (!node)
8866 return false;
8867
8868 switch (nodeTag(node))
8869 {
8870 case T_Var:
8871 case T_Const:
8872 case T_Param:
8873 case T_CoerceToDomainValue:
8874 case T_SetToDefault:
8875 case T_CurrentOfExpr:
8876 /* single words: always simple */
8877 return true;
8878
8879 case T_SubscriptingRef:
8880 case T_ArrayExpr:
8881 case T_RowExpr:
8882 case T_CoalesceExpr:
8883 case T_MinMaxExpr:
8884 case T_SQLValueFunction:
8885 case T_XmlExpr:
8886 case T_NextValueExpr:
8887 case T_NullIfExpr:
8888 case T_Aggref:
8889 case T_GroupingFunc:
8890 case T_WindowFunc:
8891 case T_MergeSupportFunc:
8892 case T_FuncExpr:
8893 case T_JsonConstructorExpr:
8894 case T_JsonExpr:
8895 /* function-like: name(..) or name[..] */
8896 return true;
8897
8898 /* CASE keywords act as parentheses */
8899 case T_CaseExpr:
8900 return true;
8901
8902 case T_FieldSelect:
8903
8904 /*
8905 * appears simple since . has top precedence, unless parent is
8906 * T_FieldSelect itself!
8907 */
8908 return !IsA(parentNode, FieldSelect);
8909
8910 case T_FieldStore:
8911
8912 /*
8913 * treat like FieldSelect (probably doesn't matter)
8914 */
8915 return !IsA(parentNode, FieldStore);
8916
8917 case T_CoerceToDomain:
8918 /* maybe simple, check args */
8919 return isSimpleNode((Node *) ((CoerceToDomain *) node)->arg,
8920 node, prettyFlags);
8921 case T_RelabelType:
8922 return isSimpleNode((Node *) ((RelabelType *) node)->arg,
8923 node, prettyFlags);
8924 case T_CoerceViaIO:
8925 return isSimpleNode((Node *) ((CoerceViaIO *) node)->arg,
8926 node, prettyFlags);
8927 case T_ArrayCoerceExpr:
8928 return isSimpleNode((Node *) ((ArrayCoerceExpr *) node)->arg,
8929 node, prettyFlags);
8930 case T_ConvertRowtypeExpr:
8931 return isSimpleNode((Node *) ((ConvertRowtypeExpr *) node)->arg,
8932 node, prettyFlags);
8933 case T_ReturningExpr:
8934 return isSimpleNode((Node *) ((ReturningExpr *) node)->retexpr,
8935 node, prettyFlags);
8936
8937 case T_OpExpr:
8938 {
8939 /* depends on parent node type; needs further checking */
8940 if (prettyFlags & PRETTYFLAG_PAREN && IsA(parentNode, OpExpr))
8941 {
8942 const char *op;
8943 const char *parentOp;
8944 bool is_lopriop;
8945 bool is_hipriop;
8946 bool is_lopriparent;
8947 bool is_hipriparent;
8948
8949 op = get_simple_binary_op_name((OpExpr *) node);
8950 if (!op)
8951 return false;
8952
8953 /* We know only the basic operators + - and * / % */
8954 is_lopriop = (strchr("+-", *op) != NULL);
8955 is_hipriop = (strchr("*/%", *op) != NULL);
8956 if (!(is_lopriop || is_hipriop))
8957 return false;
8958
8959 parentOp = get_simple_binary_op_name((OpExpr *) parentNode);
8960 if (!parentOp)
8961 return false;
8962
8963 is_lopriparent = (strchr("+-", *parentOp) != NULL);
8964 is_hipriparent = (strchr("*/%", *parentOp) != NULL);
8965 if (!(is_lopriparent || is_hipriparent))
8966 return false;
8967
8968 if (is_hipriop && is_lopriparent)
8969 return true; /* op binds tighter than parent */
8970
8971 if (is_lopriop && is_hipriparent)
8972 return false;
8973
8974 /*
8975 * Operators are same priority --- can skip parens only if
8976 * we have (a - b) - c, not a - (b - c).
8977 */
8978 if (node == (Node *) linitial(((OpExpr *) parentNode)->args))
8979 return true;
8980
8981 return false;
8982 }
8983 /* else do the same stuff as for T_SubLink et al. */
8984 }
8985 /* FALLTHROUGH */
8986
8987 case T_SubLink:
8988 case T_NullTest:
8989 case T_BooleanTest:
8990 case T_DistinctExpr:
8991 case T_JsonIsPredicate:
8992 switch (nodeTag(parentNode))
8993 {
8994 case T_FuncExpr:
8995 {
8996 /* special handling for casts and COERCE_SQL_SYNTAX */
8997 CoercionForm type = ((FuncExpr *) parentNode)->funcformat;
8998
8999 if (type == COERCE_EXPLICIT_CAST ||
9000 type == COERCE_IMPLICIT_CAST ||
9001 type == COERCE_SQL_SYNTAX)
9002 return false;
9003 return true; /* own parentheses */
9004 }
9005 case T_BoolExpr: /* lower precedence */
9006 case T_SubscriptingRef: /* other separators */
9007 case T_ArrayExpr: /* other separators */
9008 case T_RowExpr: /* other separators */
9009 case T_CoalesceExpr: /* own parentheses */
9010 case T_MinMaxExpr: /* own parentheses */
9011 case T_XmlExpr: /* own parentheses */
9012 case T_NullIfExpr: /* other separators */
9013 case T_Aggref: /* own parentheses */
9014 case T_GroupingFunc: /* own parentheses */
9015 case T_WindowFunc: /* own parentheses */
9016 case T_CaseExpr: /* other separators */
9017 return true;
9018 default:
9019 return false;
9020 }
9021
9022 case T_BoolExpr:
9023 switch (nodeTag(parentNode))
9024 {
9025 case T_BoolExpr:
9026 if (prettyFlags & PRETTYFLAG_PAREN)
9027 {
9028 BoolExprType type;
9029 BoolExprType parentType;
9030
9031 type = ((BoolExpr *) node)->boolop;
9032 parentType = ((BoolExpr *) parentNode)->boolop;
9033 switch (type)
9034 {
9035 case NOT_EXPR:
9036 case AND_EXPR:
9037 if (parentType == AND_EXPR || parentType == OR_EXPR)
9038 return true;
9039 break;
9040 case OR_EXPR:
9041 if (parentType == OR_EXPR)
9042 return true;
9043 break;
9044 }
9045 }
9046 return false;
9047 case T_FuncExpr:
9048 {
9049 /* special handling for casts and COERCE_SQL_SYNTAX */
9050 CoercionForm type = ((FuncExpr *) parentNode)->funcformat;
9051
9052 if (type == COERCE_EXPLICIT_CAST ||
9053 type == COERCE_IMPLICIT_CAST ||
9054 type == COERCE_SQL_SYNTAX)
9055 return false;
9056 return true; /* own parentheses */
9057 }
9058 case T_SubscriptingRef: /* other separators */
9059 case T_ArrayExpr: /* other separators */
9060 case T_RowExpr: /* other separators */
9061 case T_CoalesceExpr: /* own parentheses */
9062 case T_MinMaxExpr: /* own parentheses */
9063 case T_XmlExpr: /* own parentheses */
9064 case T_NullIfExpr: /* other separators */
9065 case T_Aggref: /* own parentheses */
9066 case T_GroupingFunc: /* own parentheses */
9067 case T_WindowFunc: /* own parentheses */
9068 case T_CaseExpr: /* other separators */
9069 case T_JsonExpr: /* own parentheses */
9070 return true;
9071 default:
9072 return false;
9073 }
9074
9075 case T_JsonValueExpr:
9076 /* maybe simple, check args */
9077 return isSimpleNode((Node *) ((JsonValueExpr *) node)->raw_expr,
9078 node, prettyFlags);
9079
9080 default:
9081 break;
9082 }
9083 /* those we don't know: in dubio complexo */
9084 return false;
9085}
9086
9087
9088/*
9089 * appendContextKeyword - append a keyword to buffer
9090 *
9091 * If prettyPrint is enabled, perform a line break, and adjust indentation.
9092 * Otherwise, just append the keyword.
9093 */
9094static void
9095appendContextKeyword(deparse_context *context, const char *str,
9096 int indentBefore, int indentAfter, int indentPlus)
9097{
9098 StringInfo buf = context->buf;
9099
9100 if (PRETTY_INDENT(context))
9101 {
9102 int indentAmount;
9103
9104 context->indentLevel += indentBefore;
9105
9106 /* remove any trailing spaces currently in the buffer ... */
9107 removeStringInfoSpaces(buf);
9108 /* ... then add a newline and some spaces */
9109 appendStringInfoChar(buf, '\n');
9110
9111 if (context->indentLevel < PRETTYINDENT_LIMIT)
9112 indentAmount = Max(context->indentLevel, 0) + indentPlus;
9113 else
9114 {
9115 /*
9116 * If we're indented more than PRETTYINDENT_LIMIT characters, try
9117 * to conserve horizontal space by reducing the per-level
9118 * indentation. For best results the scale factor here should
9119 * divide all the indent amounts that get added to indentLevel
9120 * (PRETTYINDENT_STD, etc). It's important that the indentation
9121 * not grow unboundedly, else deeply-nested trees use O(N^2)
9122 * whitespace; so we also wrap modulo PRETTYINDENT_LIMIT.
9123 */
9124 indentAmount = PRETTYINDENT_LIMIT +
9125 (context->indentLevel - PRETTYINDENT_LIMIT) /
9126 (PRETTYINDENT_STD / 2);
9127 indentAmount %= PRETTYINDENT_LIMIT;
9128 /* scale/wrap logic affects indentLevel, but not indentPlus */
9129 indentAmount += indentPlus;
9130 }
9131 appendStringInfoSpaces(buf, indentAmount);
9132
9133 appendStringInfoString(buf, str);
9134
9135 context->indentLevel += indentAfter;
9136 if (context->indentLevel < 0)
9137 context->indentLevel = 0;
9138 }
9139 else
9140 appendStringInfoString(buf, str);
9141}
9142
9143/*
9144 * removeStringInfoSpaces - delete trailing spaces from a buffer.
9145 *
9146 * Possibly this should move to stringinfo.c at some point.
9147 */
9148static void
9149removeStringInfoSpaces(StringInfo str)
9150{
9151 while (str->len > 0 && str->data[str->len - 1] == ' ')
9152 str->data[--(str->len)] = '\0';
9153}
9154
9155
9156/*
9157 * get_rule_expr_paren - deparse expr using get_rule_expr,
9158 * embracing the string with parentheses if necessary for prettyPrint.
9159 *
9160 * Never embrace if prettyFlags=0, because it's done in the calling node.
9161 *
9162 * Any node that does *not* embrace its argument node by sql syntax (with
9163 * parentheses, non-operator keywords like CASE/WHEN/ON, or comma etc) should
9164 * use get_rule_expr_paren instead of get_rule_expr so parentheses can be
9165 * added.
9166 */
9167static void
9168get_rule_expr_paren(Node *node, deparse_context *context,
9169 bool showimplicit, Node *parentNode)
9170{
9171 bool need_paren;
9172
9173 need_paren = PRETTY_PAREN(context) &&
9174 !isSimpleNode(node, parentNode, context->prettyFlags);
9175
9176 if (need_paren)
9177 appendStringInfoChar(context->buf, '(');
9178
9179 get_rule_expr(node, context, showimplicit);
9180
9181 if (need_paren)
9182 appendStringInfoChar(context->buf, ')');
9183}
9184
9185static void
9186get_json_behavior(JsonBehavior *behavior, deparse_context *context,
9187 const char *on)
9188{
9189 /*
9190 * The order of array elements must correspond to the order of
9191 * JsonBehaviorType members.
9192 */
9193 const char *behavior_names[] =
9194 {
9195 " NULL",
9196 " ERROR",
9197 " EMPTY",
9198 " TRUE",
9199 " FALSE",
9200 " UNKNOWN",
9201 " EMPTY ARRAY",
9202 " EMPTY OBJECT",
9203 " DEFAULT "
9204 };
9205
9206 if ((int) behavior->btype < 0 || behavior->btype >= lengthof(behavior_names))
9207 elog(ERROR, "invalid json behavior type: %d", behavior->btype);
9208
9209 appendStringInfoString(context->buf, behavior_names[behavior->btype]);
9210
9211 if (behavior->btype == JSON_BEHAVIOR_DEFAULT)
9212 get_rule_expr(behavior->expr, context, false);
9213
9214 appendStringInfo(context->buf, " ON %s", on);
9215}
9216
9217/*
9218 * get_json_expr_options
9219 *
9220 * Parse back common options for JSON_QUERY, JSON_VALUE, JSON_EXISTS and
9221 * JSON_TABLE columns.
9222 */
9223static void
9224get_json_expr_options(JsonExpr *jsexpr, deparse_context *context,
9225 JsonBehaviorType default_behavior)
9226{
9227 if (jsexpr->op == JSON_QUERY_OP)
9228 {
9229 if (jsexpr->wrapper == JSW_CONDITIONAL)
9230 appendStringInfoString(context->buf, " WITH CONDITIONAL WRAPPER");
9231 else if (jsexpr->wrapper == JSW_UNCONDITIONAL)
9232 appendStringInfoString(context->buf, " WITH UNCONDITIONAL WRAPPER");
9233 /* The default */
9234 else if (jsexpr->wrapper == JSW_NONE || jsexpr->wrapper == JSW_UNSPEC)
9235 appendStringInfoString(context->buf, " WITHOUT WRAPPER");
9236
9237 if (jsexpr->omit_quotes)
9238 appendStringInfoString(context->buf, " OMIT QUOTES");
9239 /* The default */
9240 else
9241 appendStringInfoString(context->buf, " KEEP QUOTES");
9242 }
9243
9244 if (jsexpr->on_empty && jsexpr->on_empty->btype != default_behavior)
9245 get_json_behavior(jsexpr->on_empty, context, "EMPTY");
9246
9247 if (jsexpr->on_error && jsexpr->on_error->btype != default_behavior)
9248 get_json_behavior(jsexpr->on_error, context, "ERROR");
9249}
9250
9251/* ----------
9252 * get_rule_expr - Parse back an expression
9253 *
9254 * Note: showimplicit determines whether we display any implicit cast that
9255 * is present at the top of the expression tree. It is a passed argument,
9256 * not a field of the context struct, because we change the value as we
9257 * recurse down into the expression. In general we suppress implicit casts
9258 * when the result type is known with certainty (eg, the arguments of an
9259 * OR must be boolean). We display implicit casts for arguments of functions
9260 * and operators, since this is needed to be certain that the same function
9261 * or operator will be chosen when the expression is re-parsed.
9262 * ----------
9263 */
9264static void
9265get_rule_expr(Node *node, deparse_context *context,
9266 bool showimplicit)
9267{
9268 StringInfo buf = context->buf;
9269
9270 if (node == NULL)
9271 return;
9272
9273 /* Guard against excessively long or deeply-nested queries */
9274 CHECK_FOR_INTERRUPTS();
9275 check_stack_depth();
9276
9277 /*
9278 * Each level of get_rule_expr must emit an indivisible term
9279 * (parenthesized if necessary) to ensure result is reparsed into the same
9280 * expression tree. The only exception is that when the input is a List,
9281 * we emit the component items comma-separated with no surrounding
9282 * decoration; this is convenient for most callers.
9283 */
9284 switch (nodeTag(node))
9285 {
9286 case T_Var:
9287 (void) get_variable((Var *) node, 0, false, context);
9288 break;
9289
9290 case T_Const:
9291 get_const_expr((Const *) node, context, 0);
9292 break;
9293
9294 case T_Param:
9295 get_parameter((Param *) node, context);
9296 break;
9297
9298 case T_Aggref:
9299 get_agg_expr((Aggref *) node, context, (Aggref *) node);
9300 break;
9301
9302 case T_GroupingFunc:
9303 {
9304 GroupingFunc *gexpr = (GroupingFunc *) node;
9305
9306 appendStringInfoString(buf, "GROUPING(");
9307 get_rule_expr((Node *) gexpr->args, context, true);
9308 appendStringInfoChar(buf, ')');
9309 }
9310 break;
9311
9312 case T_WindowFunc:
9313 get_windowfunc_expr((WindowFunc *) node, context);
9314 break;
9315
9316 case T_MergeSupportFunc:
9317 appendStringInfoString(buf, "MERGE_ACTION()");
9318 break;
9319
9320 case T_SubscriptingRef:
9321 {
9322 SubscriptingRef *sbsref = (SubscriptingRef *) node;
9323 bool need_parens;
9324
9325 /*
9326 * If the argument is a CaseTestExpr, we must be inside a
9327 * FieldStore, ie, we are assigning to an element of an array
9328 * within a composite column. Since we already punted on
9329 * displaying the FieldStore's target information, just punt
9330 * here too, and display only the assignment source
9331 * expression.
9332 */
9333 if (IsA(sbsref->refexpr, CaseTestExpr))
9334 {
9335 Assert(sbsref->refassgnexpr);
9336 get_rule_expr((Node *) sbsref->refassgnexpr,
9337 context, showimplicit);
9338 break;
9339 }
9340
9341 /*
9342 * Parenthesize the argument unless it's a simple Var or a
9343 * FieldSelect. (In particular, if it's another
9344 * SubscriptingRef, we *must* parenthesize to avoid
9345 * confusion.)
9346 */
9347 need_parens = !IsA(sbsref->refexpr, Var) &&
9348 !IsA(sbsref->refexpr, FieldSelect);
9349 if (need_parens)
9350 appendStringInfoChar(buf, '(');
9351 get_rule_expr((Node *) sbsref->refexpr, context, showimplicit);
9352 if (need_parens)
9353 appendStringInfoChar(buf, ')');
9354
9355 /*
9356 * If there's a refassgnexpr, we want to print the node in the
9357 * format "container[subscripts] := refassgnexpr". This is
9358 * not legal SQL, so decompilation of INSERT or UPDATE
9359 * statements should always use processIndirection as part of
9360 * the statement-level syntax. We should only see this when
9361 * EXPLAIN tries to print the targetlist of a plan resulting
9362 * from such a statement.
9363 */
9364 if (sbsref->refassgnexpr)
9365 {
9366 Node *refassgnexpr;
9367
9368 /*
9369 * Use processIndirection to print this node's subscripts
9370 * as well as any additional field selections or
9371 * subscripting in immediate descendants. It returns the
9372 * RHS expr that is actually being "assigned".
9373 */
9374 refassgnexpr = processIndirection(node, context);
9375 appendStringInfoString(buf, " := ");
9376 get_rule_expr(refassgnexpr, context, showimplicit);
9377 }
9378 else
9379 {
9380 /* Just an ordinary container fetch, so print subscripts */
9381 printSubscripts(sbsref, context);
9382 }
9383 }
9384 break;
9385
9386 case T_FuncExpr:
9387 get_func_expr((FuncExpr *) node, context, showimplicit);
9388 break;
9389
9390 case T_NamedArgExpr:
9391 {
9392 NamedArgExpr *na = (NamedArgExpr *) node;
9393
9394 appendStringInfo(buf, "%s => ", quote_identifier(na->name));
9395 get_rule_expr((Node *) na->arg, context, showimplicit);
9396 }
9397 break;
9398
9399 case T_OpExpr:
9400 get_oper_expr((OpExpr *) node, context);
9401 break;
9402
9403 case T_DistinctExpr:
9404 {
9405 DistinctExpr *expr = (DistinctExpr *) node;
9406 List *args = expr->args;
9407 Node *arg1 = (Node *) linitial(args);
9408 Node *arg2 = (Node *) lsecond(args);
9409
9410 if (!PRETTY_PAREN(context))
9411 appendStringInfoChar(buf, '(');
9412 get_rule_expr_paren(arg1, context, true, node);
9413 appendStringInfoString(buf, " IS DISTINCT FROM ");
9414 get_rule_expr_paren(arg2, context, true, node);
9415 if (!PRETTY_PAREN(context))
9416 appendStringInfoChar(buf, ')');
9417 }
9418 break;
9419
9420 case T_NullIfExpr:
9421 {
9422 NullIfExpr *nullifexpr = (NullIfExpr *) node;
9423
9424 appendStringInfoString(buf, "NULLIF(");
9425 get_rule_expr((Node *) nullifexpr->args, context, true);
9426 appendStringInfoChar(buf, ')');
9427 }
9428 break;
9429
9430 case T_ScalarArrayOpExpr:
9431 {
9432 ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;
9433 List *args = expr->args;
9434 Node *arg1 = (Node *) linitial(args);
9435 Node *arg2 = (Node *) lsecond(args);
9436
9437 if (!PRETTY_PAREN(context))
9438 appendStringInfoChar(buf, '(');
9439 get_rule_expr_paren(arg1, context, true, node);
9440 appendStringInfo(buf, " %s %s (",
9441 generate_operator_name(expr->opno,
9442 exprType(arg1),
9443 get_base_element_type(exprType(arg2))),
9444 expr->useOr ? "ANY" : "ALL");
9445 get_rule_expr_paren(arg2, context, true, node);
9446
9447 /*
9448 * There's inherent ambiguity in "x op ANY/ALL (y)" when y is
9449 * a bare sub-SELECT. Since we're here, the sub-SELECT must
9450 * be meant as a scalar sub-SELECT yielding an array value to
9451 * be used in ScalarArrayOpExpr; but the grammar will
9452 * preferentially interpret such a construct as an ANY/ALL
9453 * SubLink. To prevent misparsing the output that way, insert
9454 * a dummy coercion (which will be stripped by parse analysis,
9455 * so no inefficiency is added in dump and reload). This is
9456 * indeed most likely what the user wrote to get the construct
9457 * accepted in the first place.
9458 */
9459 if (IsA(arg2, SubLink) &&
9460 ((SubLink *) arg2)->subLinkType == EXPR_SUBLINK)
9461 appendStringInfo(buf, "::%s",
9462 format_type_with_typemod(exprType(arg2),
9463 exprTypmod(arg2)));
9464 appendStringInfoChar(buf, ')');
9465 if (!PRETTY_PAREN(context))
9466 appendStringInfoChar(buf, ')');
9467 }
9468 break;
9469
9470 case T_BoolExpr:
9471 {
9472 BoolExpr *expr = (BoolExpr *) node;
9473 Node *first_arg = linitial(expr->args);
9474 ListCell *arg;
9475
9476 switch (expr->boolop)
9477 {
9478 case AND_EXPR:
9479 if (!PRETTY_PAREN(context))
9480 appendStringInfoChar(buf, '(');
9481 get_rule_expr_paren(first_arg, context,
9482 false, node);
9483 for_each_from(arg, expr->args, 1)
9484 {
9485 appendStringInfoString(buf, " AND ");
9486 get_rule_expr_paren((Node *) lfirst(arg), context,
9487 false, node);
9488 }
9489 if (!PRETTY_PAREN(context))
9490 appendStringInfoChar(buf, ')');
9491 break;
9492
9493 case OR_EXPR:
9494 if (!PRETTY_PAREN(context))
9495 appendStringInfoChar(buf, '(');
9496 get_rule_expr_paren(first_arg, context,
9497 false, node);
9498 for_each_from(arg, expr->args, 1)
9499 {
9500 appendStringInfoString(buf, " OR ");
9501 get_rule_expr_paren((Node *) lfirst(arg), context,
9502 false, node);
9503 }
9504 if (!PRETTY_PAREN(context))
9505 appendStringInfoChar(buf, ')');
9506 break;
9507
9508 case NOT_EXPR:
9509 if (!PRETTY_PAREN(context))
9510 appendStringInfoChar(buf, '(');
9511 appendStringInfoString(buf, "NOT ");
9512 get_rule_expr_paren(first_arg, context,
9513 false, node);
9514 if (!PRETTY_PAREN(context))
9515 appendStringInfoChar(buf, ')');
9516 break;
9517
9518 default:
9519 elog(ERROR, "unrecognized boolop: %d",
9520 (int) expr->boolop);
9521 }
9522 }
9523 break;
9524
9525 case T_SubLink:
9526 get_sublink_expr((SubLink *) node, context);
9527 break;
9528
9529 case T_SubPlan:
9530 {
9531 SubPlan *subplan = (SubPlan *) node;
9532
9533 /*
9534 * We cannot see an already-planned subplan in rule deparsing,
9535 * only while EXPLAINing a query plan. We don't try to
9536 * reconstruct the original SQL, just reference the subplan
9537 * that appears elsewhere in EXPLAIN's result. It does seem
9538 * useful to show the subLinkType and testexpr (if any), and
9539 * we also note whether the subplan will be hashed.
9540 */
9541 switch (subplan->subLinkType)
9542 {
9543 case EXISTS_SUBLINK:
9544 appendStringInfoString(buf, "EXISTS(");
9545 Assert(subplan->testexpr == NULL);
9546 break;
9547 case ALL_SUBLINK:
9548 appendStringInfoString(buf, "(ALL ");
9549 Assert(subplan->testexpr != NULL);
9550 break;
9551 case ANY_SUBLINK:
9552 appendStringInfoString(buf, "(ANY ");
9553 Assert(subplan->testexpr != NULL);
9554 break;
9555 case ROWCOMPARE_SUBLINK:
9556 /* Parenthesizing the testexpr seems sufficient */
9557 appendStringInfoChar(buf, '(');
9558 Assert(subplan->testexpr != NULL);
9559 break;
9560 case EXPR_SUBLINK:
9561 /* No need to decorate these subplan references */
9562 appendStringInfoChar(buf, '(');
9563 Assert(subplan->testexpr == NULL);
9564 break;
9565 case MULTIEXPR_SUBLINK:
9566 /* MULTIEXPR isn't executed in the normal way */
9567 appendStringInfoString(buf, "(rescan ");
9568 Assert(subplan->testexpr == NULL);
9569 break;
9570 case ARRAY_SUBLINK:
9571 appendStringInfoString(buf, "ARRAY(");
9572 Assert(subplan->testexpr == NULL);
9573 break;
9574 case CTE_SUBLINK:
9575 /* This case is unreachable within expressions */
9576 appendStringInfoString(buf, "CTE(");
9577 Assert(subplan->testexpr == NULL);
9578 break;
9579 }
9580
9581 if (subplan->testexpr != NULL)
9582 {
9583 deparse_namespace *dpns;
9584
9585 /*
9586 * Push SubPlan into ancestors list while deparsing
9587 * testexpr, so that we can handle PARAM_EXEC references
9588 * to the SubPlan's paramIds. (This makes it look like
9589 * the SubPlan is an "ancestor" of the current plan node,
9590 * which is a little weird, but it does no harm.) In this
9591 * path, we don't need to mention the SubPlan explicitly,
9592 * because the referencing Params will show its existence.
9593 */
9594 dpns = (deparse_namespace *) linitial(context->namespaces);
9595 dpns->ancestors = lcons(subplan, dpns->ancestors);
9596
9597 get_rule_expr(subplan->testexpr, context, showimplicit);
9598 appendStringInfoChar(buf, ')');
9599
9600 dpns->ancestors = list_delete_first(dpns->ancestors);
9601 }
9602 else
9603 {
9604 const char *nameprefix;
9605
9606 /* No referencing Params, so show the SubPlan's name */
9607 if (subplan->isInitPlan)
9608 nameprefix = "InitPlan ";
9609 else
9610 nameprefix = "SubPlan ";
9611 if (subplan->useHashTable)
9612 appendStringInfo(buf, "hashed %s%s)",
9613 nameprefix, subplan->plan_name);
9614 else
9615 appendStringInfo(buf, "%s%s)",
9616 nameprefix, subplan->plan_name);
9617 }
9618 }
9619 break;
9620
9621 case T_AlternativeSubPlan:
9622 {
9623 AlternativeSubPlan *asplan = (AlternativeSubPlan *) node;
9624 ListCell *lc;
9625
9626 /*
9627 * This case cannot be reached in normal usage, since no
9628 * AlternativeSubPlan can appear either in parsetrees or
9629 * finished plan trees. We keep it just in case somebody
9630 * wants to use this code to print planner data structures.
9631 */
9632 appendStringInfoString(buf, "(alternatives: ");
9633 foreach(lc, asplan->subplans)
9634 {
9635 SubPlan *splan = lfirst_node(SubPlan, lc);
9636 const char *nameprefix;
9637
9638 if (splan->isInitPlan)
9639 nameprefix = "InitPlan ";
9640 else
9641 nameprefix = "SubPlan ";
9642 if (splan->useHashTable)
9643 appendStringInfo(buf, "hashed %s%s", nameprefix,
9644 splan->plan_name);
9645 else
9646 appendStringInfo(buf, "%s%s", nameprefix,
9647 splan->plan_name);
9648 if (lnext(asplan->subplans, lc))
9649 appendStringInfoString(buf, " or ");
9650 }
9651 appendStringInfoChar(buf, ')');
9652 }
9653 break;
9654
9655 case T_FieldSelect:
9656 {
9657 FieldSelect *fselect = (FieldSelect *) node;
9658 Node *arg = (Node *) fselect->arg;
9659 int fno = fselect->fieldnum;
9660 const char *fieldname;
9661 bool need_parens;
9662
9663 /*
9664 * Parenthesize the argument unless it's an SubscriptingRef or
9665 * another FieldSelect. Note in particular that it would be
9666 * WRONG to not parenthesize a Var argument; simplicity is not
9667 * the issue here, having the right number of names is.
9668 */
9669 need_parens = !IsA(arg, SubscriptingRef) &&
9670 !IsA(arg, FieldSelect);
9671 if (need_parens)
9672 appendStringInfoChar(buf, '(');
9673 get_rule_expr(arg, context, true);
9674 if (need_parens)
9675 appendStringInfoChar(buf, ')');
9676
9677 /*
9678 * Get and print the field name.
9679 */
9680 fieldname = get_name_for_var_field((Var *) arg, fno,
9681 0, context);
9682 appendStringInfo(buf, ".%s", quote_identifier(fieldname));
9683 }
9684 break;
9685
9686 case T_FieldStore:
9687 {
9688 FieldStore *fstore = (FieldStore *) node;
9689 bool need_parens;
9690
9691 /*
9692 * There is no good way to represent a FieldStore as real SQL,
9693 * so decompilation of INSERT or UPDATE statements should
9694 * always use processIndirection as part of the
9695 * statement-level syntax. We should only get here when
9696 * EXPLAIN tries to print the targetlist of a plan resulting
9697 * from such a statement. The plan case is even harder than
9698 * ordinary rules would be, because the planner tries to
9699 * collapse multiple assignments to the same field or subfield
9700 * into one FieldStore; so we can see a list of target fields
9701 * not just one, and the arguments could be FieldStores
9702 * themselves. We don't bother to try to print the target
9703 * field names; we just print the source arguments, with a
9704 * ROW() around them if there's more than one. This isn't
9705 * terribly complete, but it's probably good enough for
9706 * EXPLAIN's purposes; especially since anything more would be
9707 * either hopelessly confusing or an even poorer
9708 * representation of what the plan is actually doing.
9709 */
9710 need_parens = (list_length(fstore->newvals) != 1);
9711 if (need_parens)
9712 appendStringInfoString(buf, "ROW(");
9713 get_rule_expr((Node *) fstore->newvals, context, showimplicit);
9714 if (need_parens)
9715 appendStringInfoChar(buf, ')');
9716 }
9717 break;
9718
9719 case T_RelabelType:
9720 {
9721 RelabelType *relabel = (RelabelType *) node;
9722 Node *arg = (Node *) relabel->arg;
9723
9724 if (relabel->relabelformat == COERCE_IMPLICIT_CAST &&
9725 !showimplicit)
9726 {
9727 /* don't show the implicit cast */
9728 get_rule_expr_paren(arg, context, false, node);
9729 }
9730 else
9731 {
9732 get_coercion_expr(arg, context,
9733 relabel->resulttype,
9734 relabel->resulttypmod,
9735 node);
9736 }
9737 }
9738 break;
9739
9740 case T_CoerceViaIO:
9741 {
9742 CoerceViaIO *iocoerce = (CoerceViaIO *) node;
9743 Node *arg = (Node *) iocoerce->arg;
9744
9745 if (iocoerce->coerceformat == COERCE_IMPLICIT_CAST &&
9746 !showimplicit)
9747 {
9748 /* don't show the implicit cast */
9749 get_rule_expr_paren(arg, context, false, node);
9750 }
9751 else
9752 {
9753 get_coercion_expr(arg, context,
9754 iocoerce->resulttype,
9755 -1,
9756 node);
9757 }
9758 }
9759 break;
9760
9761 case T_ArrayCoerceExpr:
9762 {
9763 ArrayCoerceExpr *acoerce = (ArrayCoerceExpr *) node;
9764 Node *arg = (Node *) acoerce->arg;
9765
9766 if (acoerce->coerceformat == COERCE_IMPLICIT_CAST &&
9767 !showimplicit)
9768 {
9769 /* don't show the implicit cast */
9770 get_rule_expr_paren(arg, context, false, node);
9771 }
9772 else
9773 {
9774 get_coercion_expr(arg, context,
9775 acoerce->resulttype,
9776 acoerce->resulttypmod,
9777 node);
9778 }
9779 }
9780 break;
9781
9782 case T_ConvertRowtypeExpr:
9783 {
9784 ConvertRowtypeExpr *convert = (ConvertRowtypeExpr *) node;
9785 Node *arg = (Node *) convert->arg;
9786
9787 if (convert->convertformat == COERCE_IMPLICIT_CAST &&
9788 !showimplicit)
9789 {
9790 /* don't show the implicit cast */
9791 get_rule_expr_paren(arg, context, false, node);
9792 }
9793 else
9794 {
9795 get_coercion_expr(arg, context,
9796 convert->resulttype, -1,
9797 node);
9798 }
9799 }
9800 break;
9801
9802 case T_CollateExpr:
9803 {
9804 CollateExpr *collate = (CollateExpr *) node;
9805 Node *arg = (Node *) collate->arg;
9806
9807 if (!PRETTY_PAREN(context))
9808 appendStringInfoChar(buf, '(');
9809 get_rule_expr_paren(arg, context, showimplicit, node);
9810 appendStringInfo(buf, " COLLATE %s",
9811 generate_collation_name(collate->collOid));
9812 if (!PRETTY_PAREN(context))
9813 appendStringInfoChar(buf, ')');
9814 }
9815 break;
9816
9817 case T_CaseExpr:
9818 {
9819 CaseExpr *caseexpr = (CaseExpr *) node;
9820 ListCell *temp;
9821
9822 appendContextKeyword(context, "CASE",
9823 0, PRETTYINDENT_VAR, 0);
9824 if (caseexpr->arg)
9825 {
9826 appendStringInfoChar(buf, ' ');
9827 get_rule_expr((Node *) caseexpr->arg, context, true);
9828 }
9829 foreach(temp, caseexpr->args)
9830 {
9831 CaseWhen *when = (CaseWhen *) lfirst(temp);
9832 Node *w = (Node *) when->expr;
9833
9834 if (caseexpr->arg)
9835 {
9836 /*
9837 * The parser should have produced WHEN clauses of the
9838 * form "CaseTestExpr = RHS", possibly with an
9839 * implicit coercion inserted above the CaseTestExpr.
9840 * For accurate decompilation of rules it's essential
9841 * that we show just the RHS. However in an
9842 * expression that's been through the optimizer, the
9843 * WHEN clause could be almost anything (since the
9844 * equality operator could have been expanded into an
9845 * inline function). If we don't recognize the form
9846 * of the WHEN clause, just punt and display it as-is.
9847 */
9848 if (IsA(w, OpExpr))
9849 {
9850 List *args = ((OpExpr *) w)->args;
9851
9852 if (list_length(args) == 2 &&
9853 IsA(strip_implicit_coercions(linitial(args)),
9854 CaseTestExpr))
9855 w = (Node *) lsecond(args);
9856 }
9857 }
9858
9859 if (!PRETTY_INDENT(context))
9860 appendStringInfoChar(buf, ' ');
9861 appendContextKeyword(context, "WHEN ",
9862 0, 0, 0);
9863 get_rule_expr(w, context, false);
9864 appendStringInfoString(buf, " THEN ");
9865 get_rule_expr((Node *) when->result, context, true);
9866 }
9867 if (!PRETTY_INDENT(context))
9868 appendStringInfoChar(buf, ' ');
9869 appendContextKeyword(context, "ELSE ",
9870 0, 0, 0);
9871 get_rule_expr((Node *) caseexpr->defresult, context, true);
9872 if (!PRETTY_INDENT(context))
9873 appendStringInfoChar(buf, ' ');
9874 appendContextKeyword(context, "END",
9875 -PRETTYINDENT_VAR, 0, 0);
9876 }
9877 break;
9878
9879 case T_CaseTestExpr:
9880 {
9881 /*
9882 * Normally we should never get here, since for expressions
9883 * that can contain this node type we attempt to avoid
9884 * recursing to it. But in an optimized expression we might
9885 * be unable to avoid that (see comments for CaseExpr). If we
9886 * do see one, print it as CASE_TEST_EXPR.
9887 */
9888 appendStringInfoString(buf, "CASE_TEST_EXPR");
9889 }
9890 break;
9891
9892 case T_ArrayExpr:
9893 {
9894 ArrayExpr *arrayexpr = (ArrayExpr *) node;
9895
9896 appendStringInfoString(buf, "ARRAY[");
9897 get_rule_expr((Node *) arrayexpr->elements, context, true);
9898 appendStringInfoChar(buf, ']');
9899
9900 /*
9901 * If the array isn't empty, we assume its elements are
9902 * coerced to the desired type. If it's empty, though, we
9903 * need an explicit coercion to the array type.
9904 */
9905 if (arrayexpr->elements == NIL)
9906 appendStringInfo(buf, "::%s",
9907 format_type_with_typemod(arrayexpr->array_typeid, -1));
9908 }
9909 break;
9910
9911 case T_RowExpr:
9912 {
9913 RowExpr *rowexpr = (RowExpr *) node;
9914 TupleDesc tupdesc = NULL;
9915 ListCell *arg;
9916 int i;
9917 char *sep;
9918
9919 /*
9920 * If it's a named type and not RECORD, we may have to skip
9921 * dropped columns and/or claim there are NULLs for added
9922 * columns.
9923 */
9924 if (rowexpr->row_typeid != RECORDOID)
9925 {
9926 tupdesc = lookup_rowtype_tupdesc(rowexpr->row_typeid, -1);
9927 Assert(list_length(rowexpr->args) <= tupdesc->natts);
9928 }
9929
9930 /*
9931 * SQL99 allows "ROW" to be omitted when there is more than
9932 * one column, but for simplicity we always print it.
9933 */
9934 appendStringInfoString(buf, "ROW(");
9935 sep = "";
9936 i = 0;
9937 foreach(arg, rowexpr->args)
9938 {
9939 Node *e = (Node *) lfirst(arg);
9940
9941 if (tupdesc == NULL ||
9942 !TupleDescCompactAttr(tupdesc, i)->attisdropped)
9943 {
9944 appendStringInfoString(buf, sep);
9945 /* Whole-row Vars need special treatment here */
9946 get_rule_expr_toplevel(e, context, true);
9947 sep = ", ";
9948 }
9949 i++;
9950 }
9951 if (tupdesc != NULL)
9952 {
9953 while (i < tupdesc->natts)
9954 {
9955 if (!TupleDescCompactAttr(tupdesc, i)->attisdropped)
9956 {
9957 appendStringInfoString(buf, sep);
9958 appendStringInfoString(buf, "NULL");
9959 sep = ", ";
9960 }
9961 i++;
9962 }
9963
9964 ReleaseTupleDesc(tupdesc);
9965 }
9966 appendStringInfoChar(buf, ')');
9967 if (rowexpr->row_format == COERCE_EXPLICIT_CAST)
9968 appendStringInfo(buf, "::%s",
9969 format_type_with_typemod(rowexpr->row_typeid, -1));
9970 }
9971 break;
9972
9973 case T_RowCompareExpr:
9974 {
9975 RowCompareExpr *rcexpr = (RowCompareExpr *) node;
9976
9977 /*
9978 * SQL99 allows "ROW" to be omitted when there is more than
9979 * one column, but for simplicity we always print it. Within
9980 * a ROW expression, whole-row Vars need special treatment, so
9981 * use get_rule_list_toplevel.
9982 */
9983 appendStringInfoString(buf, "(ROW(");
9984 get_rule_list_toplevel(rcexpr->largs, context, true);
9985
9986 /*
9987 * We assume that the name of the first-column operator will
9988 * do for all the rest too. This is definitely open to
9989 * failure, eg if some but not all operators were renamed
9990 * since the construct was parsed, but there seems no way to
9991 * be perfect.
9992 */
9993 appendStringInfo(buf, ") %s ROW(",
9994 generate_operator_name(linitial_oid(rcexpr->opnos),
9995 exprType(linitial(rcexpr->largs)),
9996 exprType(linitial(rcexpr->rargs))));
9997 get_rule_list_toplevel(rcexpr->rargs, context, true);
9998 appendStringInfoString(buf, "))");
9999 }
10000 break;
10001
10002 case T_CoalesceExpr:
10003 {
10004 CoalesceExpr *coalesceexpr = (CoalesceExpr *) node;
10005
10006 appendStringInfoString(buf, "COALESCE(");
10007 get_rule_expr((Node *) coalesceexpr->args, context, true);
10008 appendStringInfoChar(buf, ')');
10009 }
10010 break;
10011
10012 case T_MinMaxExpr:
10013 {
10014 MinMaxExpr *minmaxexpr = (MinMaxExpr *) node;
10015
10016 switch (minmaxexpr->op)
10017 {
10018 case IS_GREATEST:
10019 appendStringInfoString(buf, "GREATEST(");
10020 break;
10021 case IS_LEAST:
10022 appendStringInfoString(buf, "LEAST(");
10023 break;
10024 }
10025 get_rule_expr((Node *) minmaxexpr->args, context, true);
10026 appendStringInfoChar(buf, ')');
10027 }
10028 break;
10029
10030 case T_SQLValueFunction:
10031 {
10032 SQLValueFunction *svf = (SQLValueFunction *) node;
10033
10034 /*
10035 * Note: this code knows that typmod for time, timestamp, and
10036 * timestamptz just prints as integer.
10037 */
10038 switch (svf->op)
10039 {
10040 case SVFOP_CURRENT_DATE:
10041 appendStringInfoString(buf, "CURRENT_DATE");
10042 break;
10043 case SVFOP_CURRENT_TIME:
10044 appendStringInfoString(buf, "CURRENT_TIME");
10045 break;
10046 case SVFOP_CURRENT_TIME_N:
10047 appendStringInfo(buf, "CURRENT_TIME(%d)", svf->typmod);
10048 break;
10049 case SVFOP_CURRENT_TIMESTAMP:
10050 appendStringInfoString(buf, "CURRENT_TIMESTAMP");
10051 break;
10052 case SVFOP_CURRENT_TIMESTAMP_N:
10053 appendStringInfo(buf, "CURRENT_TIMESTAMP(%d)",
10054 svf->typmod);
10055 break;
10056 case SVFOP_LOCALTIME:
10057 appendStringInfoString(buf, "LOCALTIME");
10058 break;
10059 case SVFOP_LOCALTIME_N:
10060 appendStringInfo(buf, "LOCALTIME(%d)", svf->typmod);
10061 break;
10062 case SVFOP_LOCALTIMESTAMP:
10063 appendStringInfoString(buf, "LOCALTIMESTAMP");
10064 break;
10065 case SVFOP_LOCALTIMESTAMP_N:
10066 appendStringInfo(buf, "LOCALTIMESTAMP(%d)",
10067 svf->typmod);
10068 break;
10069 case SVFOP_CURRENT_ROLE:
10070 appendStringInfoString(buf, "CURRENT_ROLE");
10071 break;
10072 case SVFOP_CURRENT_USER:
10073 appendStringInfoString(buf, "CURRENT_USER");
10074 break;
10075 case SVFOP_USER:
10076 appendStringInfoString(buf, "USER");
10077 break;
10078 case SVFOP_SESSION_USER:
10079 appendStringInfoString(buf, "SESSION_USER");
10080 break;
10081 case SVFOP_CURRENT_CATALOG:
10082 appendStringInfoString(buf, "CURRENT_CATALOG");
10083 break;
10084 case SVFOP_CURRENT_SCHEMA:
10085 appendStringInfoString(buf, "CURRENT_SCHEMA");
10086 break;
10087 }
10088 }
10089 break;
10090
10091 case T_XmlExpr:
10092 {
10093 XmlExpr *xexpr = (XmlExpr *) node;
10094 bool needcomma = false;
10095 ListCell *arg;
10096 ListCell *narg;
10097 Const *con;
10098
10099 switch (xexpr->op)
10100 {
10101 case IS_XMLCONCAT:
10102 appendStringInfoString(buf, "XMLCONCAT(");
10103 break;
10104 case IS_XMLELEMENT:
10105 appendStringInfoString(buf, "XMLELEMENT(");
10106 break;
10107 case IS_XMLFOREST:
10108 appendStringInfoString(buf, "XMLFOREST(");
10109 break;
10110 case IS_XMLPARSE:
10111 appendStringInfoString(buf, "XMLPARSE(");
10112 break;
10113 case IS_XMLPI:
10114 appendStringInfoString(buf, "XMLPI(");
10115 break;
10116 case IS_XMLROOT:
10117 appendStringInfoString(buf, "XMLROOT(");
10118 break;
10119 case IS_XMLSERIALIZE:
10120 appendStringInfoString(buf, "XMLSERIALIZE(");
10121 break;
10122 case IS_DOCUMENT:
10123 break;
10124 }
10125 if (xexpr->op == IS_XMLPARSE || xexpr->op == IS_XMLSERIALIZE)
10126 {
10127 if (xexpr->xmloption == XMLOPTION_DOCUMENT)
10128 appendStringInfoString(buf, "DOCUMENT ");
10129 else
10130 appendStringInfoString(buf, "CONTENT ");
10131 }
10132 if (xexpr->name)
10133 {
10134 appendStringInfo(buf, "NAME %s",
10135 quote_identifier(map_xml_name_to_sql_identifier(xexpr->name)));
10136 needcomma = true;
10137 }
10138 if (xexpr->named_args)
10139 {
10140 if (xexpr->op != IS_XMLFOREST)
10141 {
10142 if (needcomma)
10143 appendStringInfoString(buf, ", ");
10144 appendStringInfoString(buf, "XMLATTRIBUTES(");
10145 needcomma = false;
10146 }
10147 forboth(arg, xexpr->named_args, narg, xexpr->arg_names)
10148 {
10149 Node *e = (Node *) lfirst(arg);
10150 char *argname = strVal(lfirst(narg));
10151
10152 if (needcomma)
10153 appendStringInfoString(buf, ", ");
10154 get_rule_expr((Node *) e, context, true);
10155 appendStringInfo(buf, " AS %s",
10156 quote_identifier(map_xml_name_to_sql_identifier(argname)));
10157 needcomma = true;
10158 }
10159 if (xexpr->op != IS_XMLFOREST)
10160 appendStringInfoChar(buf, ')');
10161 }
10162 if (xexpr->args)
10163 {
10164 if (needcomma)
10165 appendStringInfoString(buf, ", ");
10166 switch (xexpr->op)
10167 {
10168 case IS_XMLCONCAT:
10169 case IS_XMLELEMENT:
10170 case IS_XMLFOREST:
10171 case IS_XMLPI:
10172 case IS_XMLSERIALIZE:
10173 /* no extra decoration needed */
10174 get_rule_expr((Node *) xexpr->args, context, true);
10175 break;
10176 case IS_XMLPARSE:
10177 Assert(list_length(xexpr->args) == 2);
10178
10179 get_rule_expr((Node *) linitial(xexpr->args),
10180 context, true);
10181
10182 con = lsecond_node(Const, xexpr->args);
10183 Assert(!con->constisnull);
10184 if (DatumGetBool(con->constvalue))
10185 appendStringInfoString(buf,
10186 " PRESERVE WHITESPACE");
10187 else
10188 appendStringInfoString(buf,
10189 " STRIP WHITESPACE");
10190 break;
10191 case IS_XMLROOT:
10192 Assert(list_length(xexpr->args) == 3);
10193
10194 get_rule_expr((Node *) linitial(xexpr->args),
10195 context, true);
10196
10197 appendStringInfoString(buf, ", VERSION ");
10198 con = (Const *) lsecond(xexpr->args);
10199 if (IsA(con, Const) &&
10200 con->constisnull)
10201 appendStringInfoString(buf, "NO VALUE");
10202 else
10203 get_rule_expr((Node *) con, context, false);
10204
10205 con = lthird_node(Const, xexpr->args);
10206 if (con->constisnull)
10207 /* suppress STANDALONE NO VALUE */ ;
10208 else
10209 {
10210 switch (DatumGetInt32(con->constvalue))
10211 {
10212 case XML_STANDALONE_YES:
10213 appendStringInfoString(buf,
10214 ", STANDALONE YES");
10215 break;
10216 case XML_STANDALONE_NO:
10217 appendStringInfoString(buf,
10218 ", STANDALONE NO");
10219 break;
10220 case XML_STANDALONE_NO_VALUE:
10221 appendStringInfoString(buf,
10222 ", STANDALONE NO VALUE");
10223 break;
10224 default:
10225 break;
10226 }
10227 }
10228 break;
10229 case IS_DOCUMENT:
10230 get_rule_expr_paren((Node *) xexpr->args, context, false, node);
10231 break;
10232 }
10233 }
10234 if (xexpr->op == IS_XMLSERIALIZE)
10235 {
10236 appendStringInfo(buf, " AS %s",
10237 format_type_with_typemod(xexpr->type,
10238 xexpr->typmod));
10239 if (xexpr->indent)
10240 appendStringInfoString(buf, " INDENT");
10241 else
10242 appendStringInfoString(buf, " NO INDENT");
10243 }
10244
10245 if (xexpr->op == IS_DOCUMENT)
10246 appendStringInfoString(buf, " IS DOCUMENT");
10247 else
10248 appendStringInfoChar(buf, ')');
10249 }
10250 break;
10251
10252 case T_NullTest:
10253 {
10254 NullTest *ntest = (NullTest *) node;
10255
10256 if (!PRETTY_PAREN(context))
10257 appendStringInfoChar(buf, '(');
10258 get_rule_expr_paren((Node *) ntest->arg, context, true, node);
10259
10260 /*
10261 * For scalar inputs, we prefer to print as IS [NOT] NULL,
10262 * which is shorter and traditional. If it's a rowtype input
10263 * but we're applying a scalar test, must print IS [NOT]
10264 * DISTINCT FROM NULL to be semantically correct.
10265 */
10266 if (ntest->argisrow ||
10267 !type_is_rowtype(exprType((Node *) ntest->arg)))
10268 {
10269 switch (ntest->nulltesttype)
10270 {
10271 case IS_NULL:
10272 appendStringInfoString(buf, " IS NULL");
10273 break;
10274 case IS_NOT_NULL:
10275 appendStringInfoString(buf, " IS NOT NULL");
10276 break;
10277 default:
10278 elog(ERROR, "unrecognized nulltesttype: %d",
10279 (int) ntest->nulltesttype);
10280 }
10281 }
10282 else
10283 {
10284 switch (ntest->nulltesttype)
10285 {
10286 case IS_NULL:
10287 appendStringInfoString(buf, " IS NOT DISTINCT FROM NULL");
10288 break;
10289 case IS_NOT_NULL:
10290 appendStringInfoString(buf, " IS DISTINCT FROM NULL");
10291 break;
10292 default:
10293 elog(ERROR, "unrecognized nulltesttype: %d",
10294 (int) ntest->nulltesttype);
10295 }
10296 }
10297 if (!PRETTY_PAREN(context))
10298 appendStringInfoChar(buf, ')');
10299 }
10300 break;
10301
10302 case T_BooleanTest:
10303 {
10304 BooleanTest *btest = (BooleanTest *) node;
10305
10306 if (!PRETTY_PAREN(context))
10307 appendStringInfoChar(buf, '(');
10308 get_rule_expr_paren((Node *) btest->arg, context, false, node);
10309 switch (btest->booltesttype)
10310 {
10311 case IS_TRUE:
10312 appendStringInfoString(buf, " IS TRUE");
10313 break;
10314 case IS_NOT_TRUE:
10315 appendStringInfoString(buf, " IS NOT TRUE");
10316 break;
10317 case IS_FALSE:
10318 appendStringInfoString(buf, " IS FALSE");
10319 break;
10320 case IS_NOT_FALSE:
10321 appendStringInfoString(buf, " IS NOT FALSE");
10322 break;
10323 case IS_UNKNOWN:
10324 appendStringInfoString(buf, " IS UNKNOWN");
10325 break;
10326 case IS_NOT_UNKNOWN:
10327 appendStringInfoString(buf, " IS NOT UNKNOWN");
10328 break;
10329 default:
10330 elog(ERROR, "unrecognized booltesttype: %d",
10331 (int) btest->booltesttype);
10332 }
10333 if (!PRETTY_PAREN(context))
10334 appendStringInfoChar(buf, ')');
10335 }
10336 break;
10337
10338 case T_CoerceToDomain:
10339 {
10340 CoerceToDomain *ctest = (CoerceToDomain *) node;
10341 Node *arg = (Node *) ctest->arg;
10342
10343 if (ctest->coercionformat == COERCE_IMPLICIT_CAST &&
10344 !showimplicit)
10345 {
10346 /* don't show the implicit cast */
10347 get_rule_expr(arg, context, false);
10348 }
10349 else
10350 {
10351 get_coercion_expr(arg, context,
10352 ctest->resulttype,
10353 ctest->resulttypmod,
10354 node);
10355 }
10356 }
10357 break;
10358
10359 case T_CoerceToDomainValue:
10360 appendStringInfoString(buf, "VALUE");
10361 break;
10362
10363 case T_SetToDefault:
10364 appendStringInfoString(buf, "DEFAULT");
10365 break;
10366
10367 case T_CurrentOfExpr:
10368 {
10369 CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
10370
10371 if (cexpr->cursor_name)
10372 appendStringInfo(buf, "CURRENT OF %s",
10373 quote_identifier(cexpr->cursor_name));
10374 else
10375 appendStringInfo(buf, "CURRENT OF $%d",
10376 cexpr->cursor_param);
10377 }
10378 break;
10379
10380 case T_NextValueExpr:
10381 {
10382 NextValueExpr *nvexpr = (NextValueExpr *) node;
10383
10384 /*
10385 * This isn't exactly nextval(), but that seems close enough
10386 * for EXPLAIN's purposes.
10387 */
10388 appendStringInfoString(buf, "nextval(");
10389 simple_quote_literal(buf,
10390 generate_relation_name(nvexpr->seqid,
10391 NIL));
10392 appendStringInfoChar(buf, ')');
10393 }
10394 break;
10395
10396 case T_InferenceElem:
10397 {
10398 InferenceElem *iexpr = (InferenceElem *) node;
10399 bool save_varprefix;
10400 bool need_parens;
10401
10402 /*
10403 * InferenceElem can only refer to target relation, so a
10404 * prefix is not useful, and indeed would cause parse errors.
10405 */
10406 save_varprefix = context->varprefix;
10407 context->varprefix = false;
10408
10409 /*
10410 * Parenthesize the element unless it's a simple Var or a bare
10411 * function call. Follows pg_get_indexdef_worker().
10412 */
10413 need_parens = !IsA(iexpr->expr, Var);
10414 if (IsA(iexpr->expr, FuncExpr) &&
10415 ((FuncExpr *) iexpr->expr)->funcformat ==
10416 COERCE_EXPLICIT_CALL)
10417 need_parens = false;
10418
10419 if (need_parens)
10420 appendStringInfoChar(buf, '(');
10421 get_rule_expr((Node *) iexpr->expr,
10422 context, false);
10423 if (need_parens)
10424 appendStringInfoChar(buf, ')');
10425
10426 context->varprefix = save_varprefix;
10427
10428 if (iexpr->infercollid)
10429 appendStringInfo(buf, " COLLATE %s",
10430 generate_collation_name(iexpr->infercollid));
10431
10432 /* Add the operator class name, if not default */
10433 if (iexpr->inferopclass)
10434 {
10435 Oid inferopclass = iexpr->inferopclass;
10436 Oid inferopcinputtype = get_opclass_input_type(iexpr->inferopclass);
10437
10438 get_opclass_name(inferopclass, inferopcinputtype, buf);
10439 }
10440 }
10441 break;
10442
10443 case T_ReturningExpr:
10444 {
10445 ReturningExpr *retExpr = (ReturningExpr *) node;
10446
10447 /*
10448 * We cannot see a ReturningExpr in rule deparsing, only while
10449 * EXPLAINing a query plan (ReturningExpr nodes are only ever
10450 * adding during query rewriting). Just display the expression
10451 * returned (an expanded view column).
10452 */
10453 get_rule_expr((Node *) retExpr->retexpr, context, showimplicit);
10454 }
10455 break;
10456
10457 case T_PartitionBoundSpec:
10458 {
10459 PartitionBoundSpec *spec = (PartitionBoundSpec *) node;
10460 ListCell *cell;
10461 char *sep;
10462
10463 if (spec->is_default)
10464 {
10465 appendStringInfoString(buf, "DEFAULT");
10466 break;
10467 }
10468
10469 switch (spec->strategy)
10470 {
10471 case PARTITION_STRATEGY_HASH:
10472 Assert(spec->modulus > 0 && spec->remainder >= 0);
10473 Assert(spec->modulus > spec->remainder);
10474
10475 appendStringInfoString(buf, "FOR VALUES");
10476 appendStringInfo(buf, " WITH (modulus %d, remainder %d)",
10477 spec->modulus, spec->remainder);
10478 break;
10479
10480 case PARTITION_STRATEGY_LIST:
10481 Assert(spec->listdatums != NIL);
10482
10483 appendStringInfoString(buf, "FOR VALUES IN (");
10484 sep = "";
10485 foreach(cell, spec->listdatums)
10486 {
10487 Const *val = lfirst_node(Const, cell);
10488
10489 appendStringInfoString(buf, sep);
10490 get_const_expr(val, context, -1);
10491 sep = ", ";
10492 }
10493
10494 appendStringInfoChar(buf, ')');
10495 break;
10496
10497 case PARTITION_STRATEGY_RANGE:
10498 Assert(spec->lowerdatums != NIL &&
10499 spec->upperdatums != NIL &&
10500 list_length(spec->lowerdatums) ==
10501 list_length(spec->upperdatums));
10502
10503 appendStringInfo(buf, "FOR VALUES FROM %s TO %s",
10504 get_range_partbound_string(spec->lowerdatums),
10505 get_range_partbound_string(spec->upperdatums));
10506 break;
10507
10508 default:
10509 elog(ERROR, "unrecognized partition strategy: %d",
10510 (int) spec->strategy);
10511 break;
10512 }
10513 }
10514 break;
10515
10516 case T_JsonValueExpr:
10517 {
10518 JsonValueExpr *jve = (JsonValueExpr *) node;
10519
10520 get_rule_expr((Node *) jve->raw_expr, context, false);
10521 get_json_format(jve->format, context->buf);
10522 }
10523 break;
10524
10525 case T_JsonConstructorExpr:
10526 get_json_constructor((JsonConstructorExpr *) node, context, false);
10527 break;
10528
10529 case T_JsonIsPredicate:
10530 {
10531 JsonIsPredicate *pred = (JsonIsPredicate *) node;
10532
10533 if (!PRETTY_PAREN(context))
10534 appendStringInfoChar(context->buf, '(');
10535
10536 get_rule_expr_paren(pred->expr, context, true, node);
10537
10538 appendStringInfoString(context->buf, " IS JSON");
10539
10540 /* TODO: handle FORMAT clause */
10541
10542 switch (pred->item_type)
10543 {
10544 case JS_TYPE_SCALAR:
10545 appendStringInfoString(context->buf, " SCALAR");
10546 break;
10547 case JS_TYPE_ARRAY:
10548 appendStringInfoString(context->buf, " ARRAY");
10549 break;
10550 case JS_TYPE_OBJECT:
10551 appendStringInfoString(context->buf, " OBJECT");
10552 break;
10553 default:
10554 break;
10555 }
10556
10557 if (pred->unique_keys)
10558 appendStringInfoString(context->buf, " WITH UNIQUE KEYS");
10559
10560 if (!PRETTY_PAREN(context))
10561 appendStringInfoChar(context->buf, ')');
10562 }
10563 break;
10564
10565 case T_JsonExpr:
10566 {
10567 JsonExpr *jexpr = (JsonExpr *) node;
10568
10569 switch (jexpr->op)
10570 {
10571 case JSON_EXISTS_OP:
10572 appendStringInfoString(buf, "JSON_EXISTS(");
10573 break;
10574 case JSON_QUERY_OP:
10575 appendStringInfoString(buf, "JSON_QUERY(");
10576 break;
10577 case JSON_VALUE_OP:
10578 appendStringInfoString(buf, "JSON_VALUE(");
10579 break;
10580 default:
10581 elog(ERROR, "unrecognized JsonExpr op: %d",
10582 (int) jexpr->op);
10583 }
10584
10585 get_rule_expr(jexpr->formatted_expr, context, showimplicit);
10586
10587 appendStringInfoString(buf, ", ");
10588
10589 get_json_path_spec(jexpr->path_spec, context, showimplicit);
10590
10591 if (jexpr->passing_values)
10592 {
10593 ListCell *lc1,
10594 *lc2;
10595 bool needcomma = false;
10596
10597 appendStringInfoString(buf, " PASSING ");
10598
10599 forboth(lc1, jexpr->passing_names,
10600 lc2, jexpr->passing_values)
10601 {
10602 if (needcomma)
10603 appendStringInfoString(buf, ", ");
10604 needcomma = true;
10605
10606 get_rule_expr((Node *) lfirst(lc2), context, showimplicit);
10607 appendStringInfo(buf, " AS %s",
10608 quote_identifier(lfirst_node(String, lc1)->sval));
10609 }
10610 }
10611
10612 if (jexpr->op != JSON_EXISTS_OP ||
10613 jexpr->returning->typid != BOOLOID)
10614 get_json_returning(jexpr->returning, context->buf,
10615 jexpr->op == JSON_QUERY_OP);
10616
10617 get_json_expr_options(jexpr, context,
10618 jexpr->op != JSON_EXISTS_OP ?
10619 JSON_BEHAVIOR_NULL :
10620 JSON_BEHAVIOR_FALSE);
10621
10622 appendStringInfoChar(buf, ')');
10623 }
10624 break;
10625
10626 case T_List:
10627 {
10628 char *sep;
10629 ListCell *l;
10630
10631 sep = "";
10632 foreach(l, (List *) node)
10633 {
10634 appendStringInfoString(buf, sep);
10635 get_rule_expr((Node *) lfirst(l), context, showimplicit);
10636 sep = ", ";
10637 }
10638 }
10639 break;
10640
10641 case T_TableFunc:
10642 get_tablefunc((TableFunc *) node, context, showimplicit);
10643 break;
10644
10645 default:
10646 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
10647 break;
10648 }
10649}
10650
10651/*
10652 * get_rule_expr_toplevel - Parse back a toplevel expression
10653 *
10654 * Same as get_rule_expr(), except that if the expr is just a Var, we pass
10655 * istoplevel = true not false to get_variable(). This causes whole-row Vars
10656 * to get printed with decoration that will prevent expansion of "*".
10657 * We need to use this in contexts such as ROW() and VALUES(), where the
10658 * parser would expand "foo.*" appearing at top level. (In principle we'd
10659 * use this in get_target_list() too, but that has additional worries about
10660 * whether to print AS, so it needs to invoke get_variable() directly anyway.)
10661 */
10662static void
10663get_rule_expr_toplevel(Node *node, deparse_context *context,
10664 bool showimplicit)
10665{
10666 if (node && IsA(node, Var))
10667 (void) get_variable((Var *) node, 0, true, context);
10668 else
10669 get_rule_expr(node, context, showimplicit);
10670}
10671
10672/*
10673 * get_rule_list_toplevel - Parse back a list of toplevel expressions
10674 *
10675 * Apply get_rule_expr_toplevel() to each element of a List.
10676 *
10677 * This adds commas between the expressions, but caller is responsible
10678 * for printing surrounding decoration.
10679 */
10680static void
10681get_rule_list_toplevel(List *lst, deparse_context *context,
10682 bool showimplicit)
10683{
10684 const char *sep;
10685 ListCell *lc;
10686
10687 sep = "";
10688 foreach(lc, lst)
10689 {
10690 Node *e = (Node *) lfirst(lc);
10691
10692 appendStringInfoString(context->buf, sep);
10693 get_rule_expr_toplevel(e, context, showimplicit);
10694 sep = ", ";
10695 }
10696}
10697
10698/*
10699 * get_rule_expr_funccall - Parse back a function-call expression
10700 *
10701 * Same as get_rule_expr(), except that we guarantee that the output will
10702 * look like a function call, or like one of the things the grammar treats as
10703 * equivalent to a function call (see the func_expr_windowless production).
10704 * This is needed in places where the grammar uses func_expr_windowless and
10705 * you can't substitute a parenthesized a_expr. If what we have isn't going
10706 * to look like a function call, wrap it in a dummy CAST() expression, which
10707 * will satisfy the grammar --- and, indeed, is likely what the user wrote to
10708 * produce such a thing.
10709 */
10710static void
10711get_rule_expr_funccall(Node *node, deparse_context *context,
10712 bool showimplicit)
10713{
10714 if (looks_like_function(node))
10715 get_rule_expr(node, context, showimplicit);
10716 else
10717 {
10718 StringInfo buf = context->buf;
10719
10720 appendStringInfoString(buf, "CAST(");
10721 /* no point in showing any top-level implicit cast */
10722 get_rule_expr(node, context, false);
10723 appendStringInfo(buf, " AS %s)",
10724 format_type_with_typemod(exprType(node),
10725 exprTypmod(node)));
10726 }
10727}
10728
10729/*
10730 * Helper function to identify node types that satisfy func_expr_windowless.
10731 * If in doubt, "false" is always a safe answer.
10732 */
10733static bool
10734looks_like_function(Node *node)
10735{
10736 if (node == NULL)
10737 return false; /* probably shouldn't happen */
10738 switch (nodeTag(node))
10739 {
10740 case T_FuncExpr:
10741 /* OK, unless it's going to deparse as a cast */
10742 return (((FuncExpr *) node)->funcformat == COERCE_EXPLICIT_CALL ||
10743 ((FuncExpr *) node)->funcformat == COERCE_SQL_SYNTAX);
10744 case T_NullIfExpr:
10745 case T_CoalesceExpr:
10746 case T_MinMaxExpr:
10747 case T_SQLValueFunction:
10748 case T_XmlExpr:
10749 case T_JsonExpr:
10750 /* these are all accepted by func_expr_common_subexpr */
10751 return true;
10752 default:
10753 break;
10754 }
10755 return false;
10756}
10757
10758
10759/*
10760 * get_oper_expr - Parse back an OpExpr node
10761 */
10762static void
10763get_oper_expr(OpExpr *expr, deparse_context *context)
10764{
10765 StringInfo buf = context->buf;
10766 Oid opno = expr->opno;
10767 List *args = expr->args;
10768
10769 if (!PRETTY_PAREN(context))
10770 appendStringInfoChar(buf, '(');
10771 if (list_length(args) == 2)
10772 {
10773 /* binary operator */
10774 Node *arg1 = (Node *) linitial(args);
10775 Node *arg2 = (Node *) lsecond(args);
10776
10777 get_rule_expr_paren(arg1, context, true, (Node *) expr);
10778 appendStringInfo(buf, " %s ",
10779 generate_operator_name(opno,
10780 exprType(arg1),
10781 exprType(arg2)));
10782 get_rule_expr_paren(arg2, context, true, (Node *) expr);
10783 }
10784 else
10785 {
10786 /* prefix operator */
10787 Node *arg = (Node *) linitial(args);
10788
10789 appendStringInfo(buf, "%s ",
10790 generate_operator_name(opno,
10791 InvalidOid,
10792 exprType(arg)));
10793 get_rule_expr_paren(arg, context, true, (Node *) expr);
10794 }
10795 if (!PRETTY_PAREN(context))
10796 appendStringInfoChar(buf, ')');
10797}
10798
10799/*
10800 * get_func_expr - Parse back a FuncExpr node
10801 */
10802static void
10803get_func_expr(FuncExpr *expr, deparse_context *context,
10804 bool showimplicit)
10805{
10806 StringInfo buf = context->buf;
10807 Oid funcoid = expr->funcid;
10808 Oid argtypes[FUNC_MAX_ARGS];
10809 int nargs;
10810 List *argnames;
10811 bool use_variadic;
10812 ListCell *l;
10813
10814 /*
10815 * If the function call came from an implicit coercion, then just show the
10816 * first argument --- unless caller wants to see implicit coercions.
10817 */
10818 if (expr->funcformat == COERCE_IMPLICIT_CAST && !showimplicit)
10819 {
10820 get_rule_expr_paren((Node *) linitial(expr->args), context,
10821 false, (Node *) expr);
10822 return;
10823 }
10824
10825 /*
10826 * If the function call came from a cast, then show the first argument
10827 * plus an explicit cast operation.
10828 */
10829 if (expr->funcformat == COERCE_EXPLICIT_CAST ||
10830 expr->funcformat == COERCE_IMPLICIT_CAST)
10831 {
10832 Node *arg = linitial(expr->args);
10833 Oid rettype = expr->funcresulttype;
10834 int32 coercedTypmod;
10835
10836 /* Get the typmod if this is a length-coercion function */
10837 (void) exprIsLengthCoercion((Node *) expr, &coercedTypmod);
10838
10839 get_coercion_expr(arg, context,
10840 rettype, coercedTypmod,
10841 (Node *) expr);
10842
10843 return;
10844 }
10845
10846 /*
10847 * If the function was called using one of the SQL spec's random special
10848 * syntaxes, try to reproduce that. If we don't recognize the function,
10849 * fall through.
10850 */
10851 if (expr->funcformat == COERCE_SQL_SYNTAX)
10852 {
10853 if (get_func_sql_syntax(expr, context))
10854 return;
10855 }
10856
10857 /*
10858 * Normal function: display as proname(args). First we need to extract
10859 * the argument datatypes.
10860 */
10861 if (list_length(expr->args) > FUNC_MAX_ARGS)
10862 ereport(ERROR,
10863 (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
10864 errmsg("too many arguments")));
10865 nargs = 0;
10866 argnames = NIL;
10867 foreach(l, expr->args)
10868 {
10869 Node *arg = (Node *) lfirst(l);
10870
10871 if (IsA(arg, NamedArgExpr))
10872 argnames = lappend(argnames, ((NamedArgExpr *) arg)->name);
10873 argtypes[nargs] = exprType(arg);
10874 nargs++;
10875 }
10876
10877 appendStringInfo(buf, "%s(",
10878 generate_function_name(funcoid, nargs,
10879 argnames, argtypes,
10880 expr->funcvariadic,
10881 &use_variadic,
10882 context->inGroupBy));
10883 nargs = 0;
10884 foreach(l, expr->args)
10885 {
10886 if (nargs++ > 0)
10887 appendStringInfoString(buf, ", ");
10888 if (use_variadic && lnext(expr->args, l) == NULL)
10889 appendStringInfoString(buf, "VARIADIC ");
10890 get_rule_expr((Node *) lfirst(l), context, true);
10891 }
10892 appendStringInfoChar(buf, ')');
10893}
10894
10895/*
10896 * get_agg_expr - Parse back an Aggref node
10897 */
10898static void
10899get_agg_expr(Aggref *aggref, deparse_context *context,
10900 Aggref *original_aggref)
10901{
10902 get_agg_expr_helper(aggref, context, original_aggref, NULL, NULL,
10903 false);
10904}
10905
10906/*
10907 * get_agg_expr_helper - subroutine for get_agg_expr and
10908 * get_json_agg_constructor
10909 */
10910static void
10911get_agg_expr_helper(Aggref *aggref, deparse_context *context,
10912 Aggref *original_aggref, const char *funcname,
10913 const char *options, bool is_json_objectagg)
10914{
10915 StringInfo buf = context->buf;
10916 Oid argtypes[FUNC_MAX_ARGS];
10917 int nargs;
10918 bool use_variadic = false;
10919
10920 /*
10921 * For a combining aggregate, we look up and deparse the corresponding
10922 * partial aggregate instead. This is necessary because our input
10923 * argument list has been replaced; the new argument list always has just
10924 * one element, which will point to a partial Aggref that supplies us with
10925 * transition states to combine.
10926 */
10927 if (DO_AGGSPLIT_COMBINE(aggref->aggsplit))
10928 {
10929 TargetEntry *tle;
10930
10931 Assert(list_length(aggref->args) == 1);
10932 tle = linitial_node(TargetEntry, aggref->args);
10933 resolve_special_varno((Node *) tle->expr, context,
10934 get_agg_combine_expr, original_aggref);
10935 return;
10936 }
10937
10938 /*
10939 * Mark as PARTIAL, if appropriate. We look to the original aggref so as
10940 * to avoid printing this when recursing from the code just above.
10941 */
10942 if (DO_AGGSPLIT_SKIPFINAL(original_aggref->aggsplit))
10943 appendStringInfoString(buf, "PARTIAL ");
10944
10945 /* Extract the argument types as seen by the parser */
10946 nargs = get_aggregate_argtypes(aggref, argtypes);
10947
10948 if (!funcname)
10949 funcname = generate_function_name(aggref->aggfnoid, nargs, NIL,
10950 argtypes, aggref->aggvariadic,
10951 &use_variadic,
10952 context->inGroupBy);
10953
10954 /* Print the aggregate name, schema-qualified if needed */
10955 appendStringInfo(buf, "%s(%s", funcname,
10956 (aggref->aggdistinct != NIL) ? "DISTINCT " : "");
10957
10958 if (AGGKIND_IS_ORDERED_SET(aggref->aggkind))
10959 {
10960 /*
10961 * Ordered-set aggregates do not use "*" syntax. Also, we needn't
10962 * worry about inserting VARIADIC. So we can just dump the direct
10963 * args as-is.
10964 */
10965 Assert(!aggref->aggvariadic);
10966 get_rule_expr((Node *) aggref->aggdirectargs, context, true);
10967 Assert(aggref->aggorder != NIL);
10968 appendStringInfoString(buf, ") WITHIN GROUP (ORDER BY ");
10969 get_rule_orderby(aggref->aggorder, aggref->args, false, context);
10970 }
10971 else
10972 {
10973 /* aggstar can be set only in zero-argument aggregates */
10974 if (aggref->aggstar)
10975 appendStringInfoChar(buf, '*');
10976 else
10977 {
10978 ListCell *l;
10979 int i;
10980
10981 i = 0;
10982 foreach(l, aggref->args)
10983 {
10984 TargetEntry *tle = (TargetEntry *) lfirst(l);
10985 Node *arg = (Node *) tle->expr;
10986
10987 Assert(!IsA(arg, NamedArgExpr));
10988 if (tle->resjunk)
10989 continue;
10990 if (i++ > 0)
10991 {
10992 if (is_json_objectagg)
10993 {
10994 /*
10995 * the ABSENT ON NULL and WITH UNIQUE args are printed
10996 * separately, so ignore them here
10997 */
10998 if (i > 2)
10999 break;
11000
11001 appendStringInfoString(buf, " : ");
11002 }
11003 else
11004 appendStringInfoString(buf, ", ");
11005 }
11006 if (use_variadic && i == nargs)
11007 appendStringInfoString(buf, "VARIADIC ");
11008 get_rule_expr(arg, context, true);
11009 }
11010 }
11011
11012 if (aggref->aggorder != NIL)
11013 {
11014 appendStringInfoString(buf, " ORDER BY ");
11015 get_rule_orderby(aggref->aggorder, aggref->args, false, context);
11016 }
11017 }
11018
11019 if (options)
11020 appendStringInfoString(buf, options);
11021
11022 if (aggref->aggfilter != NULL)
11023 {
11024 appendStringInfoString(buf, ") FILTER (WHERE ");
11025 get_rule_expr((Node *) aggref->aggfilter, context, false);
11026 }
11027
11028 appendStringInfoChar(buf, ')');
11029}
11030
11031/*
11032 * This is a helper function for get_agg_expr(). It's used when we deparse
11033 * a combining Aggref; resolve_special_varno locates the corresponding partial
11034 * Aggref and then calls this.
11035 */
11036static void
11037get_agg_combine_expr(Node *node, deparse_context *context, void *callback_arg)
11038{
11039 Aggref *aggref;
11040 Aggref *original_aggref = callback_arg;
11041
11042 if (!IsA(node, Aggref))
11043 elog(ERROR, "combining Aggref does not point to an Aggref");
11044
11045 aggref = (Aggref *) node;
11046 get_agg_expr(aggref, context, original_aggref);
11047}
11048
11049/*
11050 * get_windowfunc_expr - Parse back a WindowFunc node
11051 */
11052static void
11053get_windowfunc_expr(WindowFunc *wfunc, deparse_context *context)
11054{
11055 get_windowfunc_expr_helper(wfunc, context, NULL, NULL, false);
11056}
11057
11058
11059/*
11060 * get_windowfunc_expr_helper - subroutine for get_windowfunc_expr and
11061 * get_json_agg_constructor
11062 */
11063static void
11064get_windowfunc_expr_helper(WindowFunc *wfunc, deparse_context *context,
11065 const char *funcname, const char *options,
11066 bool is_json_objectagg)
11067{
11068 StringInfo buf = context->buf;
11069 Oid argtypes[FUNC_MAX_ARGS];
11070 int nargs;
11071 List *argnames;
11072 ListCell *l;
11073
11074 if (list_length(wfunc->args) > FUNC_MAX_ARGS)
11075 ereport(ERROR,
11076 (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
11077 errmsg("too many arguments")));
11078 nargs = 0;
11079 argnames = NIL;
11080 foreach(l, wfunc->args)
11081 {
11082 Node *arg = (Node *) lfirst(l);
11083
11084 if (IsA(arg, NamedArgExpr))
11085 argnames = lappend(argnames, ((NamedArgExpr *) arg)->name);
11086 argtypes[nargs] = exprType(arg);
11087 nargs++;
11088 }
11089
11090 if (!funcname)
11091 funcname = generate_function_name(wfunc->winfnoid, nargs, argnames,
11092 argtypes, false, NULL,
11093 context->inGroupBy);
11094
11095 appendStringInfo(buf, "%s(", funcname);
11096
11097 /* winstar can be set only in zero-argument aggregates */
11098 if (wfunc->winstar)
11099 appendStringInfoChar(buf, '*');
11100 else
11101 {
11102 if (is_json_objectagg)
11103 {
11104 get_rule_expr((Node *) linitial(wfunc->args), context, false);
11105 appendStringInfoString(buf, " : ");
11106 get_rule_expr((Node *) lsecond(wfunc->args), context, false);
11107 }
11108 else
11109 get_rule_expr((Node *) wfunc->args, context, true);
11110 }
11111
11112 if (options)
11113 appendStringInfoString(buf, options);
11114
11115 if (wfunc->aggfilter != NULL)
11116 {
11117 appendStringInfoString(buf, ") FILTER (WHERE ");
11118 get_rule_expr((Node *) wfunc->aggfilter, context, false);
11119 }
11120
11121 appendStringInfoString(buf, ") ");
11122
11123 if (wfunc->ignore_nulls == PARSER_IGNORE_NULLS)
11124 appendStringInfoString(buf, "IGNORE NULLS ");
11125
11126 appendStringInfoString(buf, "OVER ");
11127
11128 if (context->windowClause)
11129 {
11130 /* Query-decompilation case: search the windowClause list */
11131 foreach(l, context->windowClause)
11132 {
11133 WindowClause *wc = (WindowClause *) lfirst(l);
11134
11135 if (wc->winref == wfunc->winref)
11136 {
11137 if (wc->name)
11138 appendStringInfoString(buf, quote_identifier(wc->name));
11139 else
11140 get_rule_windowspec(wc, context->targetList, context);
11141 break;
11142 }
11143 }
11144 if (l == NULL)
11145 elog(ERROR, "could not find window clause for winref %u",
11146 wfunc->winref);
11147 }
11148 else
11149 {
11150 /*
11151 * In EXPLAIN, search the namespace stack for a matching WindowAgg
11152 * node (probably it's always the first entry), and print winname.
11153 */
11154 foreach(l, context->namespaces)
11155 {
11156 deparse_namespace *dpns = (deparse_namespace *) lfirst(l);
11157
11158 if (dpns->plan && IsA(dpns->plan, WindowAgg))
11159 {
11160 WindowAgg *wagg = (WindowAgg *) dpns->plan;
11161
11162 if (wagg->winref == wfunc->winref)
11163 {
11164 appendStringInfoString(buf, quote_identifier(wagg->winname));
11165 break;
11166 }
11167 }
11168 }
11169 if (l == NULL)
11170 elog(ERROR, "could not find window clause for winref %u",
11171 wfunc->winref);
11172 }
11173}
11174
11175/*
11176 * get_func_sql_syntax - Parse back a SQL-syntax function call
11177 *
11178 * Returns true if we successfully deparsed, false if we did not
11179 * recognize the function.
11180 */
11181static bool
11182get_func_sql_syntax(FuncExpr *expr, deparse_context *context)
11183{
11184 StringInfo buf = context->buf;
11185 Oid funcoid = expr->funcid;
11186
11187 switch (funcoid)
11188 {
11189 case F_TIMEZONE_INTERVAL_TIMESTAMP:
11190 case F_TIMEZONE_INTERVAL_TIMESTAMPTZ:
11191 case F_TIMEZONE_INTERVAL_TIMETZ:
11192 case F_TIMEZONE_TEXT_TIMESTAMP:
11193 case F_TIMEZONE_TEXT_TIMESTAMPTZ:
11194 case F_TIMEZONE_TEXT_TIMETZ:
11195 /* AT TIME ZONE ... note reversed argument order */
11196 appendStringInfoChar(buf, '(');
11197 get_rule_expr_paren((Node *) lsecond(expr->args), context, false,
11198 (Node *) expr);
11199 appendStringInfoString(buf, " AT TIME ZONE ");
11200 get_rule_expr_paren((Node *) linitial(expr->args), context, false,
11201 (Node *) expr);
11202 appendStringInfoChar(buf, ')');
11203 return true;
11204
11205 case F_TIMEZONE_TIMESTAMP:
11206 case F_TIMEZONE_TIMESTAMPTZ:
11207 case F_TIMEZONE_TIMETZ:
11208 /* AT LOCAL */
11209 appendStringInfoChar(buf, '(');
11210 get_rule_expr_paren((Node *) linitial(expr->args), context, false,
11211 (Node *) expr);
11212 appendStringInfoString(buf, " AT LOCAL)");
11213 return true;
11214
11215 case F_OVERLAPS_TIMESTAMPTZ_INTERVAL_TIMESTAMPTZ_INTERVAL:
11216 case F_OVERLAPS_TIMESTAMPTZ_INTERVAL_TIMESTAMPTZ_TIMESTAMPTZ:
11217 case F_OVERLAPS_TIMESTAMPTZ_TIMESTAMPTZ_TIMESTAMPTZ_INTERVAL:
11218 case F_OVERLAPS_TIMESTAMPTZ_TIMESTAMPTZ_TIMESTAMPTZ_TIMESTAMPTZ:
11219 case F_OVERLAPS_TIMESTAMP_INTERVAL_TIMESTAMP_INTERVAL:
11220 case F_OVERLAPS_TIMESTAMP_INTERVAL_TIMESTAMP_TIMESTAMP:
11221 case F_OVERLAPS_TIMESTAMP_TIMESTAMP_TIMESTAMP_INTERVAL:
11222 case F_OVERLAPS_TIMESTAMP_TIMESTAMP_TIMESTAMP_TIMESTAMP:
11223 case F_OVERLAPS_TIMETZ_TIMETZ_TIMETZ_TIMETZ:
11224 case F_OVERLAPS_TIME_INTERVAL_TIME_INTERVAL:
11225 case F_OVERLAPS_TIME_INTERVAL_TIME_TIME:
11226 case F_OVERLAPS_TIME_TIME_TIME_INTERVAL:
11227 case F_OVERLAPS_TIME_TIME_TIME_TIME:
11228 /* (x1, x2) OVERLAPS (y1, y2) */
11229 appendStringInfoString(buf, "((");
11230 get_rule_expr((Node *) linitial(expr->args), context, false);
11231 appendStringInfoString(buf, ", ");
11232 get_rule_expr((Node *) lsecond(expr->args), context, false);
11233 appendStringInfoString(buf, ") OVERLAPS (");
11234 get_rule_expr((Node *) lthird(expr->args), context, false);
11235 appendStringInfoString(buf, ", ");
11236 get_rule_expr((Node *) lfourth(expr->args), context, false);
11237 appendStringInfoString(buf, "))");
11238 return true;
11239
11240 case F_EXTRACT_TEXT_DATE:
11241 case F_EXTRACT_TEXT_TIME:
11242 case F_EXTRACT_TEXT_TIMETZ:
11243 case F_EXTRACT_TEXT_TIMESTAMP:
11244 case F_EXTRACT_TEXT_TIMESTAMPTZ:
11245 case F_EXTRACT_TEXT_INTERVAL:
11246 /* EXTRACT (x FROM y) */
11247 appendStringInfoString(buf, "EXTRACT(");
11248 {
11249 Const *con = (Const *) linitial(expr->args);
11250
11251 Assert(IsA(con, Const) &&
11252 con->consttype == TEXTOID &&
11253 !con->constisnull);
11254 appendStringInfoString(buf, TextDatumGetCString(con->constvalue));
11255 }
11256 appendStringInfoString(buf, " FROM ");
11257 get_rule_expr((Node *) lsecond(expr->args), context, false);
11258 appendStringInfoChar(buf, ')');
11259 return true;
11260
11261 case F_IS_NORMALIZED:
11262 /* IS xxx NORMALIZED */
11263 appendStringInfoChar(buf, '(');
11264 get_rule_expr_paren((Node *) linitial(expr->args), context, false,
11265 (Node *) expr);
11266 appendStringInfoString(buf, " IS");
11267 if (list_length(expr->args) == 2)
11268 {
11269 Const *con = (Const *) lsecond(expr->args);
11270
11271 Assert(IsA(con, Const) &&
11272 con->consttype == TEXTOID &&
11273 !con->constisnull);
11274 appendStringInfo(buf, " %s",
11275 TextDatumGetCString(con->constvalue));
11276 }
11277 appendStringInfoString(buf, " NORMALIZED)");
11278 return true;
11279
11280 case F_PG_COLLATION_FOR:
11281 /* COLLATION FOR */
11282 appendStringInfoString(buf, "COLLATION FOR (");
11283 get_rule_expr((Node *) linitial(expr->args), context, false);
11284 appendStringInfoChar(buf, ')');
11285 return true;
11286
11287 case F_NORMALIZE:
11288 /* NORMALIZE() */
11289 appendStringInfoString(buf, "NORMALIZE(");
11290 get_rule_expr((Node *) linitial(expr->args), context, false);
11291 if (list_length(expr->args) == 2)
11292 {
11293 Const *con = (Const *) lsecond(expr->args);
11294
11295 Assert(IsA(con, Const) &&
11296 con->consttype == TEXTOID &&
11297 !con->constisnull);
11298 appendStringInfo(buf, ", %s",
11299 TextDatumGetCString(con->constvalue));
11300 }
11301 appendStringInfoChar(buf, ')');
11302 return true;
11303
11304 case F_OVERLAY_BIT_BIT_INT4:
11305 case F_OVERLAY_BIT_BIT_INT4_INT4:
11306 case F_OVERLAY_BYTEA_BYTEA_INT4:
11307 case F_OVERLAY_BYTEA_BYTEA_INT4_INT4:
11308 case F_OVERLAY_TEXT_TEXT_INT4:
11309 case F_OVERLAY_TEXT_TEXT_INT4_INT4:
11310 /* OVERLAY() */
11311 appendStringInfoString(buf, "OVERLAY(");
11312 get_rule_expr((Node *) linitial(expr->args), context, false);
11313 appendStringInfoString(buf, " PLACING ");
11314 get_rule_expr((Node *) lsecond(expr->args), context, false);
11315 appendStringInfoString(buf, " FROM ");
11316 get_rule_expr((Node *) lthird(expr->args), context, false);
11317 if (list_length(expr->args) == 4)
11318 {
11319 appendStringInfoString(buf, " FOR ");
11320 get_rule_expr((Node *) lfourth(expr->args), context, false);
11321 }
11322 appendStringInfoChar(buf, ')');
11323 return true;
11324
11325 case F_POSITION_BIT_BIT:
11326 case F_POSITION_BYTEA_BYTEA:
11327 case F_POSITION_TEXT_TEXT:
11328 /* POSITION() ... extra parens since args are b_expr not a_expr */
11329 appendStringInfoString(buf, "POSITION((");
11330 get_rule_expr((Node *) lsecond(expr->args), context, false);
11331 appendStringInfoString(buf, ") IN (");
11332 get_rule_expr((Node *) linitial(expr->args), context, false);
11333 appendStringInfoString(buf, "))");
11334 return true;
11335
11336 case F_SUBSTRING_BIT_INT4:
11337 case F_SUBSTRING_BIT_INT4_INT4:
11338 case F_SUBSTRING_BYTEA_INT4:
11339 case F_SUBSTRING_BYTEA_INT4_INT4:
11340 case F_SUBSTRING_TEXT_INT4:
11341 case F_SUBSTRING_TEXT_INT4_INT4:
11342 /* SUBSTRING FROM/FOR (i.e., integer-position variants) */
11343 appendStringInfoString(buf, "SUBSTRING(");
11344 get_rule_expr((Node *) linitial(expr->args), context, false);
11345 appendStringInfoString(buf, " FROM ");
11346 get_rule_expr((Node *) lsecond(expr->args), context, false);
11347 if (list_length(expr->args) == 3)
11348 {
11349 appendStringInfoString(buf, " FOR ");
11350 get_rule_expr((Node *) lthird(expr->args), context, false);
11351 }
11352 appendStringInfoChar(buf, ')');
11353 return true;
11354
11355 case F_SUBSTRING_TEXT_TEXT_TEXT:
11356 /* SUBSTRING SIMILAR/ESCAPE */
11357 appendStringInfoString(buf, "SUBSTRING(");
11358 get_rule_expr((Node *) linitial(expr->args), context, false);
11359 appendStringInfoString(buf, " SIMILAR ");
11360 get_rule_expr((Node *) lsecond(expr->args), context, false);
11361 appendStringInfoString(buf, " ESCAPE ");
11362 get_rule_expr((Node *) lthird(expr->args), context, false);
11363 appendStringInfoChar(buf, ')');
11364 return true;
11365
11366 case F_BTRIM_BYTEA_BYTEA:
11367 case F_BTRIM_TEXT:
11368 case F_BTRIM_TEXT_TEXT:
11369 /* TRIM() */
11370 appendStringInfoString(buf, "TRIM(BOTH");
11371 if (list_length(expr->args) == 2)
11372 {
11373 appendStringInfoChar(buf, ' ');
11374 get_rule_expr((Node *) lsecond(expr->args), context, false);
11375 }
11376 appendStringInfoString(buf, " FROM ");
11377 get_rule_expr((Node *) linitial(expr->args), context, false);
11378 appendStringInfoChar(buf, ')');
11379 return true;
11380
11381 case F_LTRIM_BYTEA_BYTEA:
11382 case F_LTRIM_TEXT:
11383 case F_LTRIM_TEXT_TEXT:
11384 /* TRIM() */
11385 appendStringInfoString(buf, "TRIM(LEADING");
11386 if (list_length(expr->args) == 2)
11387 {
11388 appendStringInfoChar(buf, ' ');
11389 get_rule_expr((Node *) lsecond(expr->args), context, false);
11390 }
11391 appendStringInfoString(buf, " FROM ");
11392 get_rule_expr((Node *) linitial(expr->args), context, false);
11393 appendStringInfoChar(buf, ')');
11394 return true;
11395
11396 case F_RTRIM_BYTEA_BYTEA:
11397 case F_RTRIM_TEXT:
11398 case F_RTRIM_TEXT_TEXT:
11399 /* TRIM() */
11400 appendStringInfoString(buf, "TRIM(TRAILING");
11401 if (list_length(expr->args) == 2)
11402 {
11403 appendStringInfoChar(buf, ' ');
11404 get_rule_expr((Node *) lsecond(expr->args), context, false);
11405 }
11406 appendStringInfoString(buf, " FROM ");
11407 get_rule_expr((Node *) linitial(expr->args), context, false);
11408 appendStringInfoChar(buf, ')');
11409 return true;
11410
11411 case F_SYSTEM_USER:
11412 appendStringInfoString(buf, "SYSTEM_USER");
11413 return true;
11414
11415 case F_XMLEXISTS:
11416 /* XMLEXISTS ... extra parens because args are c_expr */
11417 appendStringInfoString(buf, "XMLEXISTS((");
11418 get_rule_expr((Node *) linitial(expr->args), context, false);
11419 appendStringInfoString(buf, ") PASSING (");
11420 get_rule_expr((Node *) lsecond(expr->args), context, false);
11421 appendStringInfoString(buf, "))");
11422 return true;
11423 }
11424 return false;
11425}
11426
11427/* ----------
11428 * get_coercion_expr
11429 *
11430 * Make a string representation of a value coerced to a specific type
11431 * ----------
11432 */
11433static void
11434get_coercion_expr(Node *arg, deparse_context *context,
11435 Oid resulttype, int32 resulttypmod,
11436 Node *parentNode)
11437{
11438 StringInfo buf = context->buf;
11439
11440 /*
11441 * Since parse_coerce.c doesn't immediately collapse application of
11442 * length-coercion functions to constants, what we'll typically see in
11443 * such cases is a Const with typmod -1 and a length-coercion function
11444 * right above it. Avoid generating redundant output. However, beware of
11445 * suppressing casts when the user actually wrote something like
11446 * 'foo'::text::char(3).
11447 *
11448 * Note: it might seem that we are missing the possibility of needing to
11449 * print a COLLATE clause for such a Const. However, a Const could only
11450 * have nondefault collation in a post-constant-folding tree, in which the
11451 * length coercion would have been folded too. See also the special
11452 * handling of CollateExpr in coerce_to_target_type(): any collation
11453 * marking will be above the coercion node, not below it.
11454 */
11455 if (arg && IsA(arg, Const) &&
11456 ((Const *) arg)->consttype == resulttype &&
11457 ((Const *) arg)->consttypmod == -1)
11458 {
11459 /* Show the constant without normal ::typename decoration */
11460 get_const_expr((Const *) arg, context, -1);
11461 }
11462 else
11463 {
11464 if (!PRETTY_PAREN(context))
11465 appendStringInfoChar(buf, '(');
11466 get_rule_expr_paren(arg, context, false, parentNode);
11467 if (!PRETTY_PAREN(context))
11468 appendStringInfoChar(buf, ')');
11469 }
11470
11471 /*
11472 * Never emit resulttype(arg) functional notation. A pg_proc entry could
11473 * take precedence, and a resulttype in pg_temp would require schema
11474 * qualification that format_type_with_typemod() would usually omit. We've
11475 * standardized on arg::resulttype, but CAST(arg AS resulttype) notation
11476 * would work fine.
11477 */
11478 appendStringInfo(buf, "::%s",
11479 format_type_with_typemod(resulttype, resulttypmod));
11480}
11481
11482/* ----------
11483 * get_const_expr
11484 *
11485 * Make a string representation of a Const
11486 *
11487 * showtype can be -1 to never show "::typename" decoration, or +1 to always
11488 * show it, or 0 to show it only if the constant wouldn't be assumed to be
11489 * the right type by default.
11490 *
11491 * If the Const's collation isn't default for its type, show that too.
11492 * We mustn't do this when showtype is -1 (since that means the caller will
11493 * print "::typename", and we can't put a COLLATE clause in between). It's
11494 * caller's responsibility that collation isn't missed in such cases.
11495 * ----------
11496 */
11497static void
11498get_const_expr(Const *constval, deparse_context *context, int showtype)
11499{
11500 StringInfo buf = context->buf;
11501 Oid typoutput;
11502 bool typIsVarlena;
11503 char *extval;
11504 bool needlabel = false;
11505
11506 if (constval->constisnull)
11507 {
11508 /*
11509 * Always label the type of a NULL constant to prevent misdecisions
11510 * about type when reparsing.
11511 */
11512 appendStringInfoString(buf, "NULL");
11513 if (showtype >= 0)
11514 {
11515 appendStringInfo(buf, "::%s",
11516 format_type_with_typemod(constval->consttype,
11517 constval->consttypmod));
11518 get_const_collation(constval, context);
11519 }
11520 return;
11521 }
11522
11523 getTypeOutputInfo(constval->consttype,
11524 &typoutput, &typIsVarlena);
11525
11526 extval = OidOutputFunctionCall(typoutput, constval->constvalue);
11527
11528 switch (constval->consttype)
11529 {
11530 case INT4OID:
11531
11532 /*
11533 * INT4 can be printed without any decoration, unless it is
11534 * negative; in that case print it as '-nnn'::integer to ensure
11535 * that the output will re-parse as a constant, not as a constant
11536 * plus operator. In most cases we could get away with printing
11537 * (-nnn) instead, because of the way that gram.y handles negative
11538 * literals; but that doesn't work for INT_MIN, and it doesn't
11539 * seem that much prettier anyway.
11540 */
11541 if (extval[0] != '-')
11542 appendStringInfoString(buf, extval);
11543 else
11544 {
11545 appendStringInfo(buf, "'%s'", extval);
11546 needlabel = true; /* we must attach a cast */
11547 }
11548 break;
11549
11550 case NUMERICOID:
11551
11552 /*
11553 * NUMERIC can be printed without quotes if it looks like a float
11554 * constant (not an integer, and not Infinity or NaN) and doesn't
11555 * have a leading sign (for the same reason as for INT4).
11556 */
11557 if (isdigit((unsigned char) extval[0]) &&
11558 strcspn(extval, "eE.") != strlen(extval))
11559 {
11560 appendStringInfoString(buf, extval);
11561 }
11562 else
11563 {
11564 appendStringInfo(buf, "'%s'", extval);
11565 needlabel = true; /* we must attach a cast */
11566 }
11567 break;
11568
11569 case BOOLOID:
11570 if (strcmp(extval, "t") == 0)
11571 appendStringInfoString(buf, "true");
11572 else
11573 appendStringInfoString(buf, "false");
11574 break;
11575
11576 default:
11577 simple_quote_literal(buf, extval);
11578 break;
11579 }
11580
11581 pfree(extval);
11582
11583 if (showtype < 0)
11584 return;
11585
11586 /*
11587 * For showtype == 0, append ::typename unless the constant will be
11588 * implicitly typed as the right type when it is read in.
11589 *
11590 * XXX this code has to be kept in sync with the behavior of the parser,
11591 * especially make_const.
11592 */
11593 switch (constval->consttype)
11594 {
11595 case BOOLOID:
11596 case UNKNOWNOID:
11597 /* These types can be left unlabeled */
11598 needlabel = false;
11599 break;
11600 case INT4OID:
11601 /* We determined above whether a label is needed */
11602 break;
11603 case NUMERICOID:
11604
11605 /*
11606 * Float-looking constants will be typed as numeric, which we
11607 * checked above; but if there's a nondefault typmod we need to
11608 * show it.
11609 */
11610 needlabel |= (constval->consttypmod >= 0);
11611 break;
11612 default:
11613 needlabel = true;
11614 break;
11615 }
11616 if (needlabel || showtype > 0)
11617 appendStringInfo(buf, "::%s",
11618 format_type_with_typemod(constval->consttype,
11619 constval->consttypmod));
11620
11621 get_const_collation(constval, context);
11622}
11623
11624/*
11625 * helper for get_const_expr: append COLLATE if needed
11626 */
11627static void
11628get_const_collation(Const *constval, deparse_context *context)
11629{
11630 StringInfo buf = context->buf;
11631
11632 if (OidIsValid(constval->constcollid))
11633 {
11634 Oid typcollation = get_typcollation(constval->consttype);
11635
11636 if (constval->constcollid != typcollation)
11637 {
11638 appendStringInfo(buf, " COLLATE %s",
11639 generate_collation_name(constval->constcollid));
11640 }
11641 }
11642}
11643
11644/*
11645 * get_json_path_spec - Parse back a JSON path specification
11646 */
11647static void
11648get_json_path_spec(Node *path_spec, deparse_context *context, bool showimplicit)
11649{
11650 if (IsA(path_spec, Const))
11651 get_const_expr((Const *) path_spec, context, -1);
11652 else
11653 get_rule_expr(path_spec, context, showimplicit);
11654}
11655
11656/*
11657 * get_json_format - Parse back a JsonFormat node
11658 */
11659static void
11660get_json_format(JsonFormat *format, StringInfo buf)
11661{
11662 if (format->format_type == JS_FORMAT_DEFAULT)
11663 return;
11664
11665 appendStringInfoString(buf,
11666 format->format_type == JS_FORMAT_JSONB ?
11667 " FORMAT JSONB" : " FORMAT JSON");
11668
11669 if (format->encoding != JS_ENC_DEFAULT)
11670 {
11671 const char *encoding;
11672
11673 encoding =
11674 format->encoding == JS_ENC_UTF16 ? "UTF16" :
11675 format->encoding == JS_ENC_UTF32 ? "UTF32" : "UTF8";
11676
11677 appendStringInfo(buf, " ENCODING %s", encoding);
11678 }
11679}
11680
11681/*
11682 * get_json_returning - Parse back a JsonReturning structure
11683 */
11684static void
11685get_json_returning(JsonReturning *returning, StringInfo buf,
11686 bool json_format_by_default)
11687{
11688 if (!OidIsValid(returning->typid))
11689 return;
11690
11691 appendStringInfo(buf, " RETURNING %s",
11692 format_type_with_typemod(returning->typid,
11693 returning->typmod));
11694
11695 if (!json_format_by_default ||
11696 returning->format->format_type !=
11697 (returning->typid == JSONBOID ? JS_FORMAT_JSONB : JS_FORMAT_JSON))
11698 get_json_format(returning->format, buf);
11699}
11700
11701/*
11702 * get_json_constructor - Parse back a JsonConstructorExpr node
11703 */
11704static void
11705get_json_constructor(JsonConstructorExpr *ctor, deparse_context *context,
11706 bool showimplicit)
11707{
11708 StringInfo buf = context->buf;
11709 const char *funcname;
11710 bool is_json_object;
11711 int curridx;
11712 ListCell *lc;
11713
11714 if (ctor->type == JSCTOR_JSON_OBJECTAGG)
11715 {
11716 get_json_agg_constructor(ctor, context, "JSON_OBJECTAGG", true);
11717 return;
11718 }
11719 else if (ctor->type == JSCTOR_JSON_ARRAYAGG)
11720 {
11721 get_json_agg_constructor(ctor, context, "JSON_ARRAYAGG", false);
11722 return;
11723 }
11724
11725 switch (ctor->type)
11726 {
11727 case JSCTOR_JSON_OBJECT:
11728 funcname = "JSON_OBJECT";
11729 break;
11730 case JSCTOR_JSON_ARRAY:
11731 funcname = "JSON_ARRAY";
11732 break;
11733 case JSCTOR_JSON_PARSE:
11734 funcname = "JSON";
11735 break;
11736 case JSCTOR_JSON_SCALAR:
11737 funcname = "JSON_SCALAR";
11738 break;
11739 case JSCTOR_JSON_SERIALIZE:
11740 funcname = "JSON_SERIALIZE";
11741 break;
11742 default:
11743 elog(ERROR, "invalid JsonConstructorType %d", ctor->type);
11744 }
11745
11746 appendStringInfo(buf, "%s(", funcname);
11747
11748 is_json_object = ctor->type == JSCTOR_JSON_OBJECT;
11749 foreach(lc, ctor->args)
11750 {
11751 curridx = foreach_current_index(lc);
11752 if (curridx > 0)
11753 {
11754 const char *sep;
11755
11756 sep = (is_json_object && (curridx % 2) != 0) ? " : " : ", ";
11757 appendStringInfoString(buf, sep);
11758 }
11759
11760 get_rule_expr((Node *) lfirst(lc), context, true);
11761 }
11762
11763 get_json_constructor_options(ctor, buf);
11764 appendStringInfoChar(buf, ')');
11765}
11766
11767/*
11768 * Append options, if any, to the JSON constructor being deparsed
11769 */
11770static void
11771get_json_constructor_options(JsonConstructorExpr *ctor, StringInfo buf)
11772{
11773 if (ctor->absent_on_null)
11774 {
11775 if (ctor->type == JSCTOR_JSON_OBJECT ||
11776 ctor->type == JSCTOR_JSON_OBJECTAGG)
11777 appendStringInfoString(buf, " ABSENT ON NULL");
11778 }
11779 else
11780 {
11781 if (ctor->type == JSCTOR_JSON_ARRAY ||
11782 ctor->type == JSCTOR_JSON_ARRAYAGG)
11783 appendStringInfoString(buf, " NULL ON NULL");
11784 }
11785
11786 if (ctor->unique)
11787 appendStringInfoString(buf, " WITH UNIQUE KEYS");
11788
11789 /*
11790 * Append RETURNING clause if needed; JSON() and JSON_SCALAR() don't
11791 * support one.
11792 */
11793 if (ctor->type != JSCTOR_JSON_PARSE && ctor->type != JSCTOR_JSON_SCALAR)
11794 get_json_returning(ctor->returning, buf, true);
11795}
11796
11797/*
11798 * get_json_agg_constructor - Parse back an aggregate JsonConstructorExpr node
11799 */
11800static void
11801get_json_agg_constructor(JsonConstructorExpr *ctor, deparse_context *context,
11802 const char *funcname, bool is_json_objectagg)
11803{
11804 StringInfoData options;
11805
11806 initStringInfo(&options);
11807 get_json_constructor_options(ctor, &options);
11808
11809 if (IsA(ctor->func, Aggref))
11810 get_agg_expr_helper((Aggref *) ctor->func, context,
11811 (Aggref *) ctor->func,
11812 funcname, options.data, is_json_objectagg);
11813 else if (IsA(ctor->func, WindowFunc))
11814 get_windowfunc_expr_helper((WindowFunc *) ctor->func, context,
11815 funcname, options.data,
11816 is_json_objectagg);
11817 else
11818 elog(ERROR, "invalid JsonConstructorExpr underlying node type: %d",
11819 nodeTag(ctor->func));
11820}
11821
11822/*
11823 * simple_quote_literal - Format a string as a SQL literal, append to buf
11824 */
11825static void
11826simple_quote_literal(StringInfo buf, const char *val)
11827{
11828 const char *valptr;
11829
11830 /*
11831 * We form the string literal according to the prevailing setting of
11832 * standard_conforming_strings; we never use E''. User is responsible for
11833 * making sure result is used correctly.
11834 */
11835 appendStringInfoChar(buf, '\'');
11836 for (valptr = val; *valptr; valptr++)
11837 {
11838 char ch = *valptr;
11839
11840 if (SQL_STR_DOUBLE(ch, !standard_conforming_strings))
11841 appendStringInfoChar(buf, ch);
11842 appendStringInfoChar(buf, ch);
11843 }
11844 appendStringInfoChar(buf, '\'');
11845}
11846
11847
11848/* ----------
11849 * get_sublink_expr - Parse back a sublink
11850 * ----------
11851 */
11852static void
11853get_sublink_expr(SubLink *sublink, deparse_context *context)
11854{
11855 StringInfo buf = context->buf;
11856 Query *query = (Query *) (sublink->subselect);
11857 char *opname = NULL;
11858 bool need_paren;
11859
11860 if (sublink->subLinkType == ARRAY_SUBLINK)
11861 appendStringInfoString(buf, "ARRAY(");
11862 else
11863 appendStringInfoChar(buf, '(');
11864
11865 /*
11866 * Note that we print the name of only the first operator, when there are
11867 * multiple combining operators. This is an approximation that could go
11868 * wrong in various scenarios (operators in different schemas, renamed
11869 * operators, etc) but there is not a whole lot we can do about it, since
11870 * the syntax allows only one operator to be shown.
11871 */
11872 if (sublink->testexpr)
11873 {
11874 if (IsA(sublink->testexpr, OpExpr))
11875 {
11876 /* single combining operator */
11877 OpExpr *opexpr = (OpExpr *) sublink->testexpr;
11878
11879 get_rule_expr(linitial(opexpr->args), context, true);
11880 opname = generate_operator_name(opexpr->opno,
11881 exprType(linitial(opexpr->args)),
11882 exprType(lsecond(opexpr->args)));
11883 }
11884 else if (IsA(sublink->testexpr, BoolExpr))
11885 {
11886 /* multiple combining operators, = or <> cases */
11887 char *sep;
11888 ListCell *l;
11889
11890 appendStringInfoChar(buf, '(');
11891 sep = "";
11892 foreach(l, ((BoolExpr *) sublink->testexpr)->args)
11893 {
11894 OpExpr *opexpr = lfirst_node(OpExpr, l);
11895
11896 appendStringInfoString(buf, sep);
11897 get_rule_expr(linitial(opexpr->args), context, true);
11898 if (!opname)
11899 opname = generate_operator_name(opexpr->opno,
11900 exprType(linitial(opexpr->args)),
11901 exprType(lsecond(opexpr->args)));
11902 sep = ", ";
11903 }
11904 appendStringInfoChar(buf, ')');
11905 }
11906 else if (IsA(sublink->testexpr, RowCompareExpr))
11907 {
11908 /* multiple combining operators, < <= > >= cases */
11909 RowCompareExpr *rcexpr = (RowCompareExpr *) sublink->testexpr;
11910
11911 appendStringInfoChar(buf, '(');
11912 get_rule_expr((Node *) rcexpr->largs, context, true);
11913 opname = generate_operator_name(linitial_oid(rcexpr->opnos),
11914 exprType(linitial(rcexpr->largs)),
11915 exprType(linitial(rcexpr->rargs)));
11916 appendStringInfoChar(buf, ')');
11917 }
11918 else
11919 elog(ERROR, "unrecognized testexpr type: %d",
11920 (int) nodeTag(sublink->testexpr));
11921 }
11922
11923 need_paren = true;
11924
11925 switch (sublink->subLinkType)
11926 {
11927 case EXISTS_SUBLINK:
11928 appendStringInfoString(buf, "EXISTS ");
11929 break;
11930
11931 case ANY_SUBLINK:
11932 if (strcmp(opname, "=") == 0) /* Represent = ANY as IN */
11933 appendStringInfoString(buf, " IN ");
11934 else
11935 appendStringInfo(buf, " %s ANY ", opname);
11936 break;
11937
11938 case ALL_SUBLINK:
11939 appendStringInfo(buf, " %s ALL ", opname);
11940 break;
11941
11942 case ROWCOMPARE_SUBLINK:
11943 appendStringInfo(buf, " %s ", opname);
11944 break;
11945
11946 case EXPR_SUBLINK:
11947 case MULTIEXPR_SUBLINK:
11948 case ARRAY_SUBLINK:
11949 need_paren = false;
11950 break;
11951
11952 case CTE_SUBLINK: /* shouldn't occur in a SubLink */
11953 default:
11954 elog(ERROR, "unrecognized sublink type: %d",
11955 (int) sublink->subLinkType);
11956 break;
11957 }
11958
11959 if (need_paren)
11960 appendStringInfoChar(buf, '(');
11961
11962 get_query_def(query, buf, context->namespaces, NULL, false,
11963 context->prettyFlags, context->wrapColumn,
11964 context->indentLevel);
11965
11966 if (need_paren)
11967 appendStringInfoString(buf, "))");
11968 else
11969 appendStringInfoChar(buf, ')');
11970}
11971
11972
11973/* ----------
11974 * get_xmltable - Parse back a XMLTABLE function
11975 * ----------
11976 */
11977static void
11978get_xmltable(TableFunc *tf, deparse_context *context, bool showimplicit)
11979{
11980 StringInfo buf = context->buf;
11981
11982 appendStringInfoString(buf, "XMLTABLE(");
11983
11984 if (tf->ns_uris != NIL)
11985 {
11986 ListCell *lc1,
11987 *lc2;
11988 bool first = true;
11989
11990 appendStringInfoString(buf, "XMLNAMESPACES (");
11991 forboth(lc1, tf->ns_uris, lc2, tf->ns_names)
11992 {
11993 Node *expr = (Node *) lfirst(lc1);
11994 String *ns_node = lfirst_node(String, lc2);
11995
11996 if (!first)
11997 appendStringInfoString(buf, ", ");
11998 else
11999 first = false;
12000
12001 if (ns_node != NULL)
12002 {
12003 get_rule_expr(expr, context, showimplicit);
12004 appendStringInfo(buf, " AS %s",
12005 quote_identifier(strVal(ns_node)));
12006 }
12007 else
12008 {
12009 appendStringInfoString(buf, "DEFAULT ");
12010 get_rule_expr(expr, context, showimplicit);
12011 }
12012 }
12013 appendStringInfoString(buf, "), ");
12014 }
12015
12016 appendStringInfoChar(buf, '(');
12017 get_rule_expr((Node *) tf->rowexpr, context, showimplicit);
12018 appendStringInfoString(buf, ") PASSING (");
12019 get_rule_expr((Node *) tf->docexpr, context, showimplicit);
12020 appendStringInfoChar(buf, ')');
12021
12022 if (tf->colexprs != NIL)
12023 {
12024 ListCell *l1;
12025 ListCell *l2;
12026 ListCell *l3;
12027 ListCell *l4;
12028 ListCell *l5;
12029 int colnum = 0;
12030
12031 appendStringInfoString(buf, " COLUMNS ");
12032 forfive(l1, tf->colnames, l2, tf->coltypes, l3, tf->coltypmods,
12033 l4, tf->colexprs, l5, tf->coldefexprs)
12034 {
12035 char *colname = strVal(lfirst(l1));
12036 Oid typid = lfirst_oid(l2);
12037 int32 typmod = lfirst_int(l3);
12038 Node *colexpr = (Node *) lfirst(l4);
12039 Node *coldefexpr = (Node *) lfirst(l5);
12040 bool ordinality = (tf->ordinalitycol == colnum);
12041 bool notnull = bms_is_member(colnum, tf->notnulls);
12042
12043 if (colnum > 0)
12044 appendStringInfoString(buf, ", ");
12045 colnum++;
12046
12047 appendStringInfo(buf, "%s %s", quote_identifier(colname),
12048 ordinality ? "FOR ORDINALITY" :
12049 format_type_with_typemod(typid, typmod));
12050 if (ordinality)
12051 continue;
12052
12053 if (coldefexpr != NULL)
12054 {
12055 appendStringInfoString(buf, " DEFAULT (");
12056 get_rule_expr((Node *) coldefexpr, context, showimplicit);
12057 appendStringInfoChar(buf, ')');
12058 }
12059 if (colexpr != NULL)
12060 {
12061 appendStringInfoString(buf, " PATH (");
12062 get_rule_expr((Node *) colexpr, context, showimplicit);
12063 appendStringInfoChar(buf, ')');
12064 }
12065 if (notnull)
12066 appendStringInfoString(buf, " NOT NULL");
12067 }
12068 }
12069
12070 appendStringInfoChar(buf, ')');
12071}
12072
12073/*
12074 * get_json_table_nested_columns - Parse back nested JSON_TABLE columns
12075 */
12076static void
12077get_json_table_nested_columns(TableFunc *tf, JsonTablePlan *plan,
12078 deparse_context *context, bool showimplicit,
12079 bool needcomma)
12080{
12081 if (IsA(plan, JsonTablePathScan))
12082 {
12083 JsonTablePathScan *scan = castNode(JsonTablePathScan, plan);
12084
12085 if (needcomma)
12086 appendStringInfoChar(context->buf, ',');
12087
12088 appendStringInfoChar(context->buf, ' ');
12089 appendContextKeyword(context, "NESTED PATH ", 0, 0, 0);
12090 get_const_expr(scan->path->value, context, -1);
12091 appendStringInfo(context->buf, " AS %s", quote_identifier(scan->path->name));
12092 get_json_table_columns(tf, scan, context, showimplicit);
12093 }
12094 else if (IsA(plan, JsonTableSiblingJoin))
12095 {
12096 JsonTableSiblingJoin *join = (JsonTableSiblingJoin *) plan;
12097
12098 get_json_table_nested_columns(tf, join->lplan, context, showimplicit,
12099 needcomma);
12100 get_json_table_nested_columns(tf, join->rplan, context, showimplicit,
12101 true);
12102 }
12103}
12104
12105/*
12106 * get_json_table_columns - Parse back JSON_TABLE columns
12107 */
12108static void
12109get_json_table_columns(TableFunc *tf, JsonTablePathScan *scan,
12110 deparse_context *context,
12111 bool showimplicit)
12112{
12113 StringInfo buf = context->buf;
12114 ListCell *lc_colname;
12115 ListCell *lc_coltype;
12116 ListCell *lc_coltypmod;
12117 ListCell *lc_colvalexpr;
12118 int colnum = 0;
12119
12120 appendStringInfoChar(buf, ' ');
12121 appendContextKeyword(context, "COLUMNS (", 0, 0, 0);
12122
12123 if (PRETTY_INDENT(context))
12124 context->indentLevel += PRETTYINDENT_VAR;
12125
12126 forfour(lc_colname, tf->colnames,
12127 lc_coltype, tf->coltypes,
12128 lc_coltypmod, tf->coltypmods,
12129 lc_colvalexpr, tf->colvalexprs)
12130 {
12131 char *colname = strVal(lfirst(lc_colname));
12132 JsonExpr *colexpr;
12133 Oid typid;
12134 int32 typmod;
12135 bool ordinality;
12136 JsonBehaviorType default_behavior;
12137
12138 typid = lfirst_oid(lc_coltype);
12139 typmod = lfirst_int(lc_coltypmod);
12140 colexpr = castNode(JsonExpr, lfirst(lc_colvalexpr));
12141
12142 /* Skip columns that don't belong to this scan. */
12143 if (scan->colMin < 0 || colnum < scan->colMin)
12144 {
12145 colnum++;
12146 continue;
12147 }
12148 if (colnum > scan->colMax)
12149 break;
12150
12151 if (colnum > scan->colMin)
12152 appendStringInfoString(buf, ", ");
12153
12154 colnum++;
12155
12156 ordinality = !colexpr;
12157
12158 appendContextKeyword(context, "", 0, 0, 0);
12159
12160 appendStringInfo(buf, "%s %s", quote_identifier(colname),
12161 ordinality ? "FOR ORDINALITY" :
12162 format_type_with_typemod(typid, typmod));
12163 if (ordinality)
12164 continue;
12165
12166 /*
12167 * Set default_behavior to guide get_json_expr_options() on whether to
12168 * emit the ON ERROR / EMPTY clauses.
12169 */
12170 if (colexpr->op == JSON_EXISTS_OP)
12171 {
12172 appendStringInfoString(buf, " EXISTS");
12173 default_behavior = JSON_BEHAVIOR_FALSE;
12174 }
12175 else
12176 {
12177 if (colexpr->op == JSON_QUERY_OP)
12178 {
12179 char typcategory;
12180 bool typispreferred;
12181
12182 get_type_category_preferred(typid, &typcategory, &typispreferred);
12183
12184 if (typcategory == TYPCATEGORY_STRING)
12185 appendStringInfoString(buf,
12186 colexpr->format->format_type == JS_FORMAT_JSONB ?
12187 " FORMAT JSONB" : " FORMAT JSON");
12188 }
12189
12190 default_behavior = JSON_BEHAVIOR_NULL;
12191 }
12192
12193 appendStringInfoString(buf, " PATH ");
12194
12195 get_json_path_spec(colexpr->path_spec, context, showimplicit);
12196
12197 get_json_expr_options(colexpr, context, default_behavior);
12198 }
12199
12200 if (scan->child)
12201 get_json_table_nested_columns(tf, scan->child, context, showimplicit,
12202 scan->colMin >= 0);
12203
12204 if (PRETTY_INDENT(context))
12205 context->indentLevel -= PRETTYINDENT_VAR;
12206
12207 appendContextKeyword(context, ")", 0, 0, 0);
12208}
12209
12210/* ----------
12211 * get_json_table - Parse back a JSON_TABLE function
12212 * ----------
12213 */
12214static void
12215get_json_table(TableFunc *tf, deparse_context *context, bool showimplicit)
12216{
12217 StringInfo buf = context->buf;
12218 JsonExpr *jexpr = castNode(JsonExpr, tf->docexpr);
12219 JsonTablePathScan *root = castNode(JsonTablePathScan, tf->plan);
12220
12221 appendStringInfoString(buf, "JSON_TABLE(");
12222
12223 if (PRETTY_INDENT(context))
12224 context->indentLevel += PRETTYINDENT_VAR;
12225
12226 appendContextKeyword(context, "", 0, 0, 0);
12227
12228 get_rule_expr(jexpr->formatted_expr, context, showimplicit);
12229
12230 appendStringInfoString(buf, ", ");
12231
12232 get_const_expr(root->path->value, context, -1);
12233
12234 appendStringInfo(buf, " AS %s", quote_identifier(root->path->name));
12235
12236 if (jexpr->passing_values)
12237 {
12238 ListCell *lc1,
12239 *lc2;
12240 bool needcomma = false;
12241
12242 appendStringInfoChar(buf, ' ');
12243 appendContextKeyword(context, "PASSING ", 0, 0, 0);
12244
12245 if (PRETTY_INDENT(context))
12246 context->indentLevel += PRETTYINDENT_VAR;
12247
12248 forboth(lc1, jexpr->passing_names,
12249 lc2, jexpr->passing_values)
12250 {
12251 if (needcomma)
12252 appendStringInfoString(buf, ", ");
12253 needcomma = true;
12254
12255 appendContextKeyword(context, "", 0, 0, 0);
12256
12257 get_rule_expr((Node *) lfirst(lc2), context, false);
12258 appendStringInfo(buf, " AS %s",
12259 quote_identifier((lfirst_node(String, lc1))->sval)
12260 );
12261 }
12262
12263 if (PRETTY_INDENT(context))
12264 context->indentLevel -= PRETTYINDENT_VAR;
12265 }
12266
12267 get_json_table_columns(tf, castNode(JsonTablePathScan, tf->plan), context,
12268 showimplicit);
12269
12270 if (jexpr->on_error->btype != JSON_BEHAVIOR_EMPTY_ARRAY)
12271 get_json_behavior(jexpr->on_error, context, "ERROR");
12272
12273 if (PRETTY_INDENT(context))
12274 context->indentLevel -= PRETTYINDENT_VAR;
12275
12276 appendContextKeyword(context, ")", 0, 0, 0);
12277}
12278
12279/* ----------
12280 * get_tablefunc - Parse back a table function
12281 * ----------
12282 */
12283static void
12284get_tablefunc(TableFunc *tf, deparse_context *context, bool showimplicit)
12285{
12286 /* XMLTABLE and JSON_TABLE are the only existing implementations. */
12287
12288 if (tf->functype == TFT_XMLTABLE)
12289 get_xmltable(tf, context, showimplicit);
12290 else if (tf->functype == TFT_JSON_TABLE)
12291 get_json_table(tf, context, showimplicit);
12292}
12293
12294/* ----------
12295 * get_from_clause - Parse back a FROM clause
12296 *
12297 * "prefix" is the keyword that denotes the start of the list of FROM
12298 * elements. It is FROM when used to parse back SELECT and UPDATE, but
12299 * is USING when parsing back DELETE.
12300 * ----------
12301 */
12302static void
12303get_from_clause(Query *query, const char *prefix, deparse_context *context)
12304{
12305 StringInfo buf = context->buf;
12306 bool first = true;
12307 ListCell *l;
12308
12309 /*
12310 * We use the query's jointree as a guide to what to print. However, we
12311 * must ignore auto-added RTEs that are marked not inFromCl. (These can
12312 * only appear at the top level of the jointree, so it's sufficient to
12313 * check here.) This check also ensures we ignore the rule pseudo-RTEs
12314 * for NEW and OLD.
12315 */
12316 foreach(l, query->jointree->fromlist)
12317 {
12318 Node *jtnode = (Node *) lfirst(l);
12319
12320 if (IsA(jtnode, RangeTblRef))
12321 {
12322 int varno = ((RangeTblRef *) jtnode)->rtindex;
12323 RangeTblEntry *rte = rt_fetch(varno, query->rtable);
12324
12325 if (!rte->inFromCl)
12326 continue;
12327 }
12328
12329 if (first)
12330 {
12331 appendContextKeyword(context, prefix,
12332 -PRETTYINDENT_STD, PRETTYINDENT_STD, 2);
12333 first = false;
12334
12335 get_from_clause_item(jtnode, query, context);
12336 }
12337 else
12338 {
12339 StringInfoData itembuf;
12340
12341 appendStringInfoString(buf, ", ");
12342
12343 /*
12344 * Put the new FROM item's text into itembuf so we can decide
12345 * after we've got it whether or not it needs to go on a new line.
12346 */
12347 initStringInfo(&itembuf);
12348 context->buf = &itembuf;
12349
12350 get_from_clause_item(jtnode, query, context);
12351
12352 /* Restore context's output buffer */
12353 context->buf = buf;
12354
12355 /* Consider line-wrapping if enabled */
12356 if (PRETTY_INDENT(context) && context->wrapColumn >= 0)
12357 {
12358 /* Does the new item start with a new line? */
12359 if (itembuf.len > 0 && itembuf.data[0] == '\n')
12360 {
12361 /* If so, we shouldn't add anything */
12362 /* instead, remove any trailing spaces currently in buf */
12363 removeStringInfoSpaces(buf);
12364 }
12365 else
12366 {
12367 char *trailing_nl;
12368
12369 /* Locate the start of the current line in the buffer */
12370 trailing_nl = strrchr(buf->data, '\n');
12371 if (trailing_nl == NULL)
12372 trailing_nl = buf->data;
12373 else
12374 trailing_nl++;
12375
12376 /*
12377 * Add a newline, plus some indentation, if the new item
12378 * would cause an overflow.
12379 */
12380 if (strlen(trailing_nl) + itembuf.len > context->wrapColumn)
12381 appendContextKeyword(context, "", -PRETTYINDENT_STD,
12382 PRETTYINDENT_STD,
12383 PRETTYINDENT_VAR);
12384 }
12385 }
12386
12387 /* Add the new item */
12388 appendBinaryStringInfo(buf, itembuf.data, itembuf.len);
12389
12390 /* clean up */
12391 pfree(itembuf.data);
12392 }
12393 }
12394}
12395
12396static void
12397get_from_clause_item(Node *jtnode, Query *query, deparse_context *context)
12398{
12399 StringInfo buf = context->buf;
12400 deparse_namespace *dpns = (deparse_namespace *) linitial(context->namespaces);
12401
12402 if (IsA(jtnode, RangeTblRef))
12403 {
12404 int varno = ((RangeTblRef *) jtnode)->rtindex;
12405 RangeTblEntry *rte = rt_fetch(varno, query->rtable);
12406 deparse_columns *colinfo = deparse_columns_fetch(varno, dpns);
12407 RangeTblFunction *rtfunc1 = NULL;
12408
12409 if (rte->lateral)
12410 appendStringInfoString(buf, "LATERAL ");
12411
12412 /* Print the FROM item proper */
12413 switch (rte->rtekind)
12414 {
12415 case RTE_RELATION:
12416 /* Normal relation RTE */
12417 appendStringInfo(buf, "%s%s",
12418 only_marker(rte),
12419 generate_relation_name(rte->relid,
12420 context->namespaces));
12421 break;
12422 case RTE_SUBQUERY:
12423 /* Subquery RTE */
12424 appendStringInfoChar(buf, '(');
12425 get_query_def(rte->subquery, buf, context->namespaces, NULL,
12426 true,
12427 context->prettyFlags, context->wrapColumn,
12428 context->indentLevel);
12429 appendStringInfoChar(buf, ')');
12430 break;
12431 case RTE_FUNCTION:
12432 /* Function RTE */
12433 rtfunc1 = (RangeTblFunction *) linitial(rte->functions);
12434
12435 /*
12436 * Omit ROWS FROM() syntax for just one function, unless it
12437 * has both a coldeflist and WITH ORDINALITY. If it has both,
12438 * we must use ROWS FROM() syntax to avoid ambiguity about
12439 * whether the coldeflist includes the ordinality column.
12440 */
12441 if (list_length(rte->functions) == 1 &&
12442 (rtfunc1->funccolnames == NIL || !rte->funcordinality))
12443 {
12444 get_rule_expr_funccall(rtfunc1->funcexpr, context, true);
12445 /* we'll print the coldeflist below, if it has one */
12446 }
12447 else
12448 {
12449 bool all_unnest;
12450 ListCell *lc;
12451
12452 /*
12453 * If all the function calls in the list are to unnest,
12454 * and none need a coldeflist, then collapse the list back
12455 * down to UNNEST(args). (If we had more than one
12456 * built-in unnest function, this would get more
12457 * difficult.)
12458 *
12459 * XXX This is pretty ugly, since it makes not-terribly-
12460 * future-proof assumptions about what the parser would do
12461 * with the output; but the alternative is to emit our
12462 * nonstandard ROWS FROM() notation for what might have
12463 * been a perfectly spec-compliant multi-argument
12464 * UNNEST().
12465 */
12466 all_unnest = true;
12467 foreach(lc, rte->functions)
12468 {
12469 RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
12470
12471 if (!IsA(rtfunc->funcexpr, FuncExpr) ||
12472 ((FuncExpr *) rtfunc->funcexpr)->funcid != F_UNNEST_ANYARRAY ||
12473 rtfunc->funccolnames != NIL)
12474 {
12475 all_unnest = false;
12476 break;
12477 }
12478 }
12479
12480 if (all_unnest)
12481 {
12482 List *allargs = NIL;
12483
12484 foreach(lc, rte->functions)
12485 {
12486 RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
12487 List *args = ((FuncExpr *) rtfunc->funcexpr)->args;
12488
12489 allargs = list_concat(allargs, args);
12490 }
12491
12492 appendStringInfoString(buf, "UNNEST(");
12493 get_rule_expr((Node *) allargs, context, true);
12494 appendStringInfoChar(buf, ')');
12495 }
12496 else
12497 {
12498 int funcno = 0;
12499
12500 appendStringInfoString(buf, "ROWS FROM(");
12501 foreach(lc, rte->functions)
12502 {
12503 RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
12504
12505 if (funcno > 0)
12506 appendStringInfoString(buf, ", ");
12507 get_rule_expr_funccall(rtfunc->funcexpr, context, true);
12508 if (rtfunc->funccolnames != NIL)
12509 {
12510 /* Reconstruct the column definition list */
12511 appendStringInfoString(buf, " AS ");
12512 get_from_clause_coldeflist(rtfunc,
12513 NULL,
12514 context);
12515 }
12516 funcno++;
12517 }
12518 appendStringInfoChar(buf, ')');
12519 }
12520 /* prevent printing duplicate coldeflist below */
12521 rtfunc1 = NULL;
12522 }
12523 if (rte->funcordinality)
12524 appendStringInfoString(buf, " WITH ORDINALITY");
12525 break;
12526 case RTE_TABLEFUNC:
12527 get_tablefunc(rte->tablefunc, context, true);
12528 break;
12529 case RTE_VALUES:
12530 /* Values list RTE */
12531 appendStringInfoChar(buf, '(');
12532 get_values_def(rte->values_lists, context);
12533 appendStringInfoChar(buf, ')');
12534 break;
12535 case RTE_CTE:
12536 appendStringInfoString(buf, quote_identifier(rte->ctename));
12537 break;
12538 default:
12539 elog(ERROR, "unrecognized RTE kind: %d", (int) rte->rtekind);
12540 break;
12541 }
12542
12543 /* Print the relation alias, if needed */
12544 get_rte_alias(rte, varno, false, context);
12545
12546 /* Print the column definitions or aliases, if needed */
12547 if (rtfunc1 && rtfunc1->funccolnames != NIL)
12548 {
12549 /* Reconstruct the columndef list, which is also the aliases */
12550 get_from_clause_coldeflist(rtfunc1, colinfo, context);
12551 }
12552 else
12553 {
12554 /* Else print column aliases as needed */
12555 get_column_alias_list(colinfo, context);
12556 }
12557
12558 /* Tablesample clause must go after any alias */
12559 if (rte->rtekind == RTE_RELATION && rte->tablesample)
12560 get_tablesample_def(rte->tablesample, context);
12561 }
12562 else if (IsA(jtnode, JoinExpr))
12563 {
12564 JoinExpr *j = (JoinExpr *) jtnode;
12565 deparse_columns *colinfo = deparse_columns_fetch(j->rtindex, dpns);
12566 bool need_paren_on_right;
12567
12568 need_paren_on_right = PRETTY_PAREN(context) &&
12569 !IsA(j->rarg, RangeTblRef) &&
12570 !(IsA(j->rarg, JoinExpr) && ((JoinExpr *) j->rarg)->alias != NULL);
12571
12572 if (!PRETTY_PAREN(context) || j->alias != NULL)
12573 appendStringInfoChar(buf, '(');
12574
12575 get_from_clause_item(j->larg, query, context);
12576
12577 switch (j->jointype)
12578 {
12579 case JOIN_INNER:
12580 if (j->quals)
12581 appendContextKeyword(context, " JOIN ",
12582 -PRETTYINDENT_STD,
12583 PRETTYINDENT_STD,
12584 PRETTYINDENT_JOIN);
12585 else
12586 appendContextKeyword(context, " CROSS JOIN ",
12587 -PRETTYINDENT_STD,
12588 PRETTYINDENT_STD,
12589 PRETTYINDENT_JOIN);
12590 break;
12591 case JOIN_LEFT:
12592 appendContextKeyword(context, " LEFT JOIN ",
12593 -PRETTYINDENT_STD,
12594 PRETTYINDENT_STD,
12595 PRETTYINDENT_JOIN);
12596 break;
12597 case JOIN_FULL:
12598 appendContextKeyword(context, " FULL JOIN ",
12599 -PRETTYINDENT_STD,
12600 PRETTYINDENT_STD,
12601 PRETTYINDENT_JOIN);
12602 break;
12603 case JOIN_RIGHT:
12604 appendContextKeyword(context, " RIGHT JOIN ",
12605 -PRETTYINDENT_STD,
12606 PRETTYINDENT_STD,
12607 PRETTYINDENT_JOIN);
12608 break;
12609 default:
12610 elog(ERROR, "unrecognized join type: %d",
12611 (int) j->jointype);
12612 }
12613
12614 if (need_paren_on_right)
12615 appendStringInfoChar(buf, '(');
12616 get_from_clause_item(j->rarg, query, context);
12617 if (need_paren_on_right)
12618 appendStringInfoChar(buf, ')');
12619
12620 if (j->usingClause)
12621 {
12622 ListCell *lc;
12623 bool first = true;
12624
12625 appendStringInfoString(buf, " USING (");
12626 /* Use the assigned names, not what's in usingClause */
12627 foreach(lc, colinfo->usingNames)
12628 {
12629 char *colname = (char *) lfirst(lc);
12630
12631 if (first)
12632 first = false;
12633 else
12634 appendStringInfoString(buf, ", ");
12635 appendStringInfoString(buf, quote_identifier(colname));
12636 }
12637 appendStringInfoChar(buf, ')');
12638
12639 if (j->join_using_alias)
12640 appendStringInfo(buf, " AS %s",
12641 quote_identifier(j->join_using_alias->aliasname));
12642 }
12643 else if (j->quals)
12644 {
12645 appendStringInfoString(buf, " ON ");
12646 if (!PRETTY_PAREN(context))
12647 appendStringInfoChar(buf, '(');
12648 get_rule_expr(j->quals, context, false);
12649 if (!PRETTY_PAREN(context))
12650 appendStringInfoChar(buf, ')');
12651 }
12652 else if (j->jointype != JOIN_INNER)
12653 {
12654 /* If we didn't say CROSS JOIN above, we must provide an ON */
12655 appendStringInfoString(buf, " ON TRUE");
12656 }
12657
12658 if (!PRETTY_PAREN(context) || j->alias != NULL)
12659 appendStringInfoChar(buf, ')');
12660
12661 /* Yes, it's correct to put alias after the right paren ... */
12662 if (j->alias != NULL)
12663 {
12664 /*
12665 * Note that it's correct to emit an alias clause if and only if
12666 * there was one originally. Otherwise we'd be converting a named
12667 * join to unnamed or vice versa, which creates semantic
12668 * subtleties we don't want. However, we might print a different
12669 * alias name than was there originally.
12670 */
12671 appendStringInfo(buf, " %s",
12672 quote_identifier(get_rtable_name(j->rtindex,
12673 context)));
12674 get_column_alias_list(colinfo, context);
12675 }
12676 }
12677 else
12678 elog(ERROR, "unrecognized node type: %d",
12679 (int) nodeTag(jtnode));
12680}
12681
12682/*
12683 * get_rte_alias - print the relation's alias, if needed
12684 *
12685 * If printed, the alias is preceded by a space, or by " AS " if use_as is true.
12686 */
12687static void
12688get_rte_alias(RangeTblEntry *rte, int varno, bool use_as,
12689 deparse_context *context)
12690{
12691 deparse_namespace *dpns = (deparse_namespace *) linitial(context->namespaces);
12692 char *refname = get_rtable_name(varno, context);
12693 deparse_columns *colinfo = deparse_columns_fetch(varno, dpns);
12694 bool printalias = false;
12695
12696 if (rte->alias != NULL)
12697 {
12698 /* Always print alias if user provided one */
12699 printalias = true;
12700 }
12701 else if (colinfo->printaliases)
12702 {
12703 /* Always print alias if we need to print column aliases */
12704 printalias = true;
12705 }
12706 else if (rte->rtekind == RTE_RELATION)
12707 {
12708 /*
12709 * No need to print alias if it's same as relation name (this would
12710 * normally be the case, but not if set_rtable_names had to resolve a
12711 * conflict).
12712 */
12713 if (strcmp(refname, get_relation_name(rte->relid)) != 0)
12714 printalias = true;
12715 }
12716 else if (rte->rtekind == RTE_FUNCTION)
12717 {
12718 /*
12719 * For a function RTE, always print alias. This covers possible
12720 * renaming of the function and/or instability of the FigureColname
12721 * rules for things that aren't simple functions. Note we'd need to
12722 * force it anyway for the columndef list case.
12723 */
12724 printalias = true;
12725 }
12726 else if (rte->rtekind == RTE_SUBQUERY ||
12727 rte->rtekind == RTE_VALUES)
12728 {
12729 /*
12730 * For a subquery, always print alias. This makes the output
12731 * SQL-spec-compliant, even though we allow such aliases to be omitted
12732 * on input.
12733 */
12734 printalias = true;
12735 }
12736 else if (rte->rtekind == RTE_CTE)
12737 {
12738 /*
12739 * No need to print alias if it's same as CTE name (this would
12740 * normally be the case, but not if set_rtable_names had to resolve a
12741 * conflict).
12742 */
12743 if (strcmp(refname, rte->ctename) != 0)
12744 printalias = true;
12745 }
12746
12747 if (printalias)
12748 appendStringInfo(context->buf, "%s%s",
12749 use_as ? " AS " : " ",
12750 quote_identifier(refname));
12751}
12752
12753/*
12754 * get_column_alias_list - print column alias list for an RTE
12755 *
12756 * Caller must already have printed the relation's alias name.
12757 */
12758static void
12759get_column_alias_list(deparse_columns *colinfo, deparse_context *context)
12760{
12761 StringInfo buf = context->buf;
12762 int i;
12763 bool first = true;
12764
12765 /* Don't print aliases if not needed */
12766 if (!colinfo->printaliases)
12767 return;
12768
12769 for (i = 0; i < colinfo->num_new_cols; i++)
12770 {
12771 char *colname = colinfo->new_colnames[i];
12772
12773 if (first)
12774 {
12775 appendStringInfoChar(buf, '(');
12776 first = false;
12777 }
12778 else
12779 appendStringInfoString(buf, ", ");
12780 appendStringInfoString(buf, quote_identifier(colname));
12781 }
12782 if (!first)
12783 appendStringInfoChar(buf, ')');
12784}
12785
12786/*
12787 * get_from_clause_coldeflist - reproduce FROM clause coldeflist
12788 *
12789 * When printing a top-level coldeflist (which is syntactically also the
12790 * relation's column alias list), use column names from colinfo. But when
12791 * printing a coldeflist embedded inside ROWS FROM(), we prefer to use the
12792 * original coldeflist's names, which are available in rtfunc->funccolnames.
12793 * Pass NULL for colinfo to select the latter behavior.
12794 *
12795 * The coldeflist is appended immediately (no space) to buf. Caller is
12796 * responsible for ensuring that an alias or AS is present before it.
12797 */
12798static void
12799get_from_clause_coldeflist(RangeTblFunction *rtfunc,
12800 deparse_columns *colinfo,
12801 deparse_context *context)
12802{
12803 StringInfo buf = context->buf;
12804 ListCell *l1;
12805 ListCell *l2;
12806 ListCell *l3;
12807 ListCell *l4;
12808 int i;
12809
12810 appendStringInfoChar(buf, '(');
12811
12812 i = 0;
12813 forfour(l1, rtfunc->funccoltypes,
12814 l2, rtfunc->funccoltypmods,
12815 l3, rtfunc->funccolcollations,
12816 l4, rtfunc->funccolnames)
12817 {
12818 Oid atttypid = lfirst_oid(l1);
12819 int32 atttypmod = lfirst_int(l2);
12820 Oid attcollation = lfirst_oid(l3);
12821 char *attname;
12822
12823 if (colinfo)
12824 attname = colinfo->colnames[i];
12825 else
12826 attname = strVal(lfirst(l4));
12827
12828 Assert(attname); /* shouldn't be any dropped columns here */
12829
12830 if (i > 0)
12831 appendStringInfoString(buf, ", ");
12832 appendStringInfo(buf, "%s %s",
12833 quote_identifier(attname),
12834 format_type_with_typemod(atttypid, atttypmod));
12835 if (OidIsValid(attcollation) &&
12836 attcollation != get_typcollation(atttypid))
12837 appendStringInfo(buf, " COLLATE %s",
12838 generate_collation_name(attcollation));
12839
12840 i++;
12841 }
12842
12843 appendStringInfoChar(buf, ')');
12844}
12845
12846/*
12847 * get_tablesample_def - print a TableSampleClause
12848 */
12849static void
12850get_tablesample_def(TableSampleClause *tablesample, deparse_context *context)
12851{
12852 StringInfo buf = context->buf;
12853 Oid argtypes[1];
12854 int nargs;
12855 ListCell *l;
12856
12857 /*
12858 * We should qualify the handler's function name if it wouldn't be
12859 * resolved by lookup in the current search path.
12860 */
12861 argtypes[0] = INTERNALOID;
12862 appendStringInfo(buf, " TABLESAMPLE %s (",
12863 generate_function_name(tablesample->tsmhandler, 1,
12864 NIL, argtypes,
12865 false, NULL, false));
12866
12867 nargs = 0;
12868 foreach(l, tablesample->args)
12869 {
12870 if (nargs++ > 0)
12871 appendStringInfoString(buf, ", ");
12872 get_rule_expr((Node *) lfirst(l), context, false);
12873 }
12874 appendStringInfoChar(buf, ')');
12875
12876 if (tablesample->repeatable != NULL)
12877 {
12878 appendStringInfoString(buf, " REPEATABLE (");
12879 get_rule_expr((Node *) tablesample->repeatable, context, false);
12880 appendStringInfoChar(buf, ')');
12881 }
12882}
12883
12884/*
12885 * get_opclass_name - fetch name of an index operator class
12886 *
12887 * The opclass name is appended (after a space) to buf.
12888 *
12889 * Output is suppressed if the opclass is the default for the given
12890 * actual_datatype. (If you don't want this behavior, just pass
12891 * InvalidOid for actual_datatype.)
12892 */
12893static void
12894get_opclass_name(Oid opclass, Oid actual_datatype,
12895 StringInfo buf)
12896{
12897 HeapTuple ht_opc;
12898 Form_pg_opclass opcrec;
12899 char *opcname;
12900 char *nspname;
12901
12902 ht_opc = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclass));
12903 if (!HeapTupleIsValid(ht_opc))
12904 elog(ERROR, "cache lookup failed for opclass %u", opclass);
12905 opcrec = (Form_pg_opclass) GETSTRUCT(ht_opc);
12906
12907 if (!OidIsValid(actual_datatype) ||
12908 GetDefaultOpClass(actual_datatype, opcrec->opcmethod) != opclass)
12909 {
12910 /* Okay, we need the opclass name. Do we need to qualify it? */
12911 opcname = NameStr(opcrec->opcname);
12912 if (OpclassIsVisible(opclass))
12913 appendStringInfo(buf, " %s", quote_identifier(opcname));
12914 else
12915 {
12916 nspname = get_namespace_name_or_temp(opcrec->opcnamespace);
12917 appendStringInfo(buf, " %s.%s",
12918 quote_identifier(nspname),
12919 quote_identifier(opcname));
12920 }
12921 }
12922 ReleaseSysCache(ht_opc);
12923}
12924
12925/*
12926 * generate_opclass_name
12927 * Compute the name to display for an opclass specified by OID
12928 *
12929 * The result includes all necessary quoting and schema-prefixing.
12930 */
12931char *
12932generate_opclass_name(Oid opclass)
12933{
12934 StringInfoData buf;
12935
12936 initStringInfo(&buf);
12937 get_opclass_name(opclass, InvalidOid, &buf);
12938
12939 return &buf.data[1]; /* get_opclass_name() prepends space */
12940}
12941
12942/*
12943 * processIndirection - take care of array and subfield assignment
12944 *
12945 * We strip any top-level FieldStore or assignment SubscriptingRef nodes that
12946 * appear in the input, printing them as decoration for the base column
12947 * name (which we assume the caller just printed). We might also need to
12948 * strip CoerceToDomain nodes, but only ones that appear above assignment
12949 * nodes.
12950 *
12951 * Returns the subexpression that's to be assigned.
12952 */
12953static Node *
12954processIndirection(Node *node, deparse_context *context)
12955{
12956 StringInfo buf = context->buf;
12957 CoerceToDomain *cdomain = NULL;
12958
12959 for (;;)
12960 {
12961 if (node == NULL)
12962 break;
12963 if (IsA(node, FieldStore))
12964 {
12965 FieldStore *fstore = (FieldStore *) node;
12966 Oid typrelid;
12967 char *fieldname;
12968
12969 /* lookup tuple type */
12970 typrelid = get_typ_typrelid(fstore->resulttype);
12971 if (!OidIsValid(typrelid))
12972 elog(ERROR, "argument type %s of FieldStore is not a tuple type",
12973 format_type_be(fstore->resulttype));
12974
12975 /*
12976 * Print the field name. There should only be one target field in
12977 * stored rules. There could be more than that in executable
12978 * target lists, but this function cannot be used for that case.
12979 */
12980 Assert(list_length(fstore->fieldnums) == 1);
12981 fieldname = get_attname(typrelid,
12982 linitial_int(fstore->fieldnums), false);
12983 appendStringInfo(buf, ".%s", quote_identifier(fieldname));
12984
12985 /*
12986 * We ignore arg since it should be an uninteresting reference to
12987 * the target column or subcolumn.
12988 */
12989 node = (Node *) linitial(fstore->newvals);
12990 }
12991 else if (IsA(node, SubscriptingRef))
12992 {
12993 SubscriptingRef *sbsref = (SubscriptingRef *) node;
12994
12995 if (sbsref->refassgnexpr == NULL)
12996 break;
12997
12998 printSubscripts(sbsref, context);
12999
13000 /*
13001 * We ignore refexpr since it should be an uninteresting reference
13002 * to the target column or subcolumn.
13003 */
13004 node = (Node *) sbsref->refassgnexpr;
13005 }
13006 else if (IsA(node, CoerceToDomain))
13007 {
13008 cdomain = (CoerceToDomain *) node;
13009 /* If it's an explicit domain coercion, we're done */
13010 if (cdomain->coercionformat != COERCE_IMPLICIT_CAST)
13011 break;
13012 /* Tentatively descend past the CoerceToDomain */
13013 node = (Node *) cdomain->arg;
13014 }
13015 else
13016 break;
13017 }
13018
13019 /*
13020 * If we descended past a CoerceToDomain whose argument turned out not to
13021 * be a FieldStore or array assignment, back up to the CoerceToDomain.
13022 * (This is not enough to be fully correct if there are nested implicit
13023 * CoerceToDomains, but such cases shouldn't ever occur.)
13024 */
13025 if (cdomain && node == (Node *) cdomain->arg)
13026 node = (Node *) cdomain;
13027
13028 return node;
13029}
13030
13031static void
13032printSubscripts(SubscriptingRef *sbsref, deparse_context *context)
13033{
13034 StringInfo buf = context->buf;
13035 ListCell *lowlist_item;
13036 ListCell *uplist_item;
13037
13038 lowlist_item = list_head(sbsref->reflowerindexpr); /* could be NULL */
13039 foreach(uplist_item, sbsref->refupperindexpr)
13040 {
13041 appendStringInfoChar(buf, '[');
13042 if (lowlist_item)
13043 {
13044 /* If subexpression is NULL, get_rule_expr prints nothing */
13045 get_rule_expr((Node *) lfirst(lowlist_item), context, false);
13046 appendStringInfoChar(buf, ':');
13047 lowlist_item = lnext(sbsref->reflowerindexpr, lowlist_item);
13048 }
13049 /* If subexpression is NULL, get_rule_expr prints nothing */
13050 get_rule_expr((Node *) lfirst(uplist_item), context, false);
13051 appendStringInfoChar(buf, ']');
13052 }
13053}
13054
13055/*
13056 * quote_identifier - Quote an identifier only if needed
13057 *
13058 * When quotes are needed, we palloc the required space; slightly
13059 * space-wasteful but well worth it for notational simplicity.
13060 */
13061const char *
13062quote_identifier(const char *ident)
13063{
13064 /*
13065 * Can avoid quoting if ident starts with a lowercase letter or underscore
13066 * and contains only lowercase letters, digits, and underscores, *and* is
13067 * not any SQL keyword. Otherwise, supply quotes.
13068 */
13069 int nquotes = 0;
13070 bool safe;
13071 const char *ptr;
13072 char *result;
13073 char *optr;
13074
13075 /*
13076 * would like to use <ctype.h> macros here, but they might yield unwanted
13077 * locale-specific results...
13078 */
13079 safe = ((ident[0] >= 'a' && ident[0] <= 'z') || ident[0] == '_');
13080
13081 for (ptr = ident; *ptr; ptr++)
13082 {
13083 char ch = *ptr;
13084
13085 if ((ch >= 'a' && ch <= 'z') ||
13086 (ch >= '0' && ch <= '9') ||
13087 (ch == '_'))
13088 {
13089 /* okay */
13090 }
13091 else
13092 {
13093 safe = false;
13094 if (ch == '"')
13095 nquotes++;
13096 }
13097 }
13098
13099 if (quote_all_identifiers)
13100 safe = false;
13101
13102 if (safe)
13103 {
13104 /*
13105 * Check for keyword. We quote keywords except for unreserved ones.
13106 * (In some cases we could avoid quoting a col_name or type_func_name
13107 * keyword, but it seems much harder than it's worth to tell that.)
13108 *
13109 * Note: ScanKeywordLookup() does case-insensitive comparison, but
13110 * that's fine, since we already know we have all-lower-case.
13111 */
13112 int kwnum = ScanKeywordLookup(ident, &ScanKeywords);
13113
13114 if (kwnum >= 0 && ScanKeywordCategories[kwnum] != UNRESERVED_KEYWORD)
13115 safe = false;
13116 }
13117
13118 if (safe)
13119 return ident; /* no change needed */
13120
13121 result = (char *) palloc(strlen(ident) + nquotes + 2 + 1);
13122
13123 optr = result;
13124 *optr++ = '"';
13125 for (ptr = ident; *ptr; ptr++)
13126 {
13127 char ch = *ptr;
13128
13129 if (ch == '"')
13130 *optr++ = '"';
13131 *optr++ = ch;
13132 }
13133 *optr++ = '"';
13134 *optr = '\0';
13135
13136 return result;
13137}
13138
13139/*
13140 * quote_qualified_identifier - Quote a possibly-qualified identifier
13141 *
13142 * Return a name of the form qualifier.ident, or just ident if qualifier
13143 * is NULL, quoting each component if necessary. The result is palloc'd.
13144 */
13145char *
13146quote_qualified_identifier(const char *qualifier,
13147 const char *ident)
13148{
13149 StringInfoData buf;
13150
13151 initStringInfo(&buf);
13152 if (qualifier)
13153 appendStringInfo(&buf, "%s.", quote_identifier(qualifier));
13154 appendStringInfoString(&buf, quote_identifier(ident));
13155 return buf.data;
13156}
13157
13158/*
13159 * get_relation_name
13160 * Get the unqualified name of a relation specified by OID
13161 *
13162 * This differs from the underlying get_rel_name() function in that it will
13163 * throw error instead of silently returning NULL if the OID is bad.
13164 */
13165static char *
13166get_relation_name(Oid relid)
13167{
13168 char *relname = get_rel_name(relid);
13169
13170 if (!relname)
13171 elog(ERROR, "cache lookup failed for relation %u", relid);
13172 return relname;
13173}
13174
13175/*
13176 * generate_relation_name
13177 * Compute the name to display for a relation specified by OID
13178 *
13179 * The result includes all necessary quoting and schema-prefixing.
13180 *
13181 * If namespaces isn't NIL, it must be a list of deparse_namespace nodes.
13182 * We will forcibly qualify the relation name if it equals any CTE name
13183 * visible in the namespace list.
13184 */
13185static char *
13186generate_relation_name(Oid relid, List *namespaces)
13187{
13188 HeapTuple tp;
13189 Form_pg_class reltup;
13190 bool need_qual;
13191 ListCell *nslist;
13192 char *relname;
13193 char *nspname;
13194 char *result;
13195
13196 tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
13197 if (!HeapTupleIsValid(tp))
13198 elog(ERROR, "cache lookup failed for relation %u", relid);
13199 reltup = (Form_pg_class) GETSTRUCT(tp);
13200 relname = NameStr(reltup->relname);
13201
13202 /* Check for conflicting CTE name */
13203 need_qual = false;
13204 foreach(nslist, namespaces)
13205 {
13206 deparse_namespace *dpns = (deparse_namespace *) lfirst(nslist);
13207 ListCell *ctlist;
13208
13209 foreach(ctlist, dpns->ctes)
13210 {
13211 CommonTableExpr *cte = (CommonTableExpr *) lfirst(ctlist);
13212
13213 if (strcmp(cte->ctename, relname) == 0)
13214 {
13215 need_qual = true;
13216 break;
13217 }
13218 }
13219 if (need_qual)
13220 break;
13221 }
13222
13223 /* Otherwise, qualify the name if not visible in search path */
13224 if (!need_qual)
13225 need_qual = !RelationIsVisible(relid);
13226
13227 if (need_qual)
13228 nspname = get_namespace_name_or_temp(reltup->relnamespace);
13229 else
13230 nspname = NULL;
13231
13232 result = quote_qualified_identifier(nspname, relname);
13233
13234 ReleaseSysCache(tp);
13235
13236 return result;
13237}
13238
13239/*
13240 * generate_qualified_relation_name
13241 * Compute the name to display for a relation specified by OID
13242 *
13243 * As above, but unconditionally schema-qualify the name.
13244 */
13245static char *
13246generate_qualified_relation_name(Oid relid)
13247{
13248 HeapTuple tp;
13249 Form_pg_class reltup;
13250 char *relname;
13251 char *nspname;
13252 char *result;
13253
13254 tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
13255 if (!HeapTupleIsValid(tp))
13256 elog(ERROR, "cache lookup failed for relation %u", relid);
13257 reltup = (Form_pg_class) GETSTRUCT(tp);
13258 relname = NameStr(reltup->relname);
13259
13260 nspname = get_namespace_name_or_temp(reltup->relnamespace);
13261 if (!nspname)
13262 elog(ERROR, "cache lookup failed for namespace %u",
13263 reltup->relnamespace);
13264
13265 result = quote_qualified_identifier(nspname, relname);
13266
13267 ReleaseSysCache(tp);
13268
13269 return result;
13270}
13271
13272/*
13273 * generate_function_name
13274 * Compute the name to display for a function specified by OID,
13275 * given that it is being called with the specified actual arg names and
13276 * types. (Those matter because of ambiguous-function resolution rules.)
13277 *
13278 * If we're dealing with a potentially variadic function (in practice, this
13279 * means a FuncExpr or Aggref, not some other way of calling a function), then
13280 * has_variadic must specify whether variadic arguments have been merged,
13281 * and *use_variadic_p will be set to indicate whether to print VARIADIC in
13282 * the output. For non-FuncExpr cases, has_variadic should be false and
13283 * use_variadic_p can be NULL.
13284 *
13285 * inGroupBy must be true if we're deparsing a GROUP BY clause.
13286 *
13287 * The result includes all necessary quoting and schema-prefixing.
13288 */
13289static char *
13290generate_function_name(Oid funcid, int nargs, List *argnames, Oid *argtypes,
13291 bool has_variadic, bool *use_variadic_p,
13292 bool inGroupBy)
13293{
13294 char *result;
13295 HeapTuple proctup;
13296 Form_pg_proc procform;
13297 char *proname;
13298 bool use_variadic;
13299 char *nspname;
13300 FuncDetailCode p_result;
13301 int fgc_flags;
13302 Oid p_funcid;
13303 Oid p_rettype;
13304 bool p_retset;
13305 int p_nvargs;
13306 Oid p_vatype;
13307 Oid *p_true_typeids;
13308 bool force_qualify = false;
13309
13310 proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
13311 if (!HeapTupleIsValid(proctup))
13312 elog(ERROR, "cache lookup failed for function %u", funcid);
13313 procform = (Form_pg_proc) GETSTRUCT(proctup);
13314 proname = NameStr(procform->proname);
13315
13316 /*
13317 * Due to parser hacks to avoid needing to reserve CUBE, we need to force
13318 * qualification of some function names within GROUP BY.
13319 */
13320 if (inGroupBy)
13321 {
13322 if (strcmp(proname, "cube") == 0 || strcmp(proname, "rollup") == 0)
13323 force_qualify = true;
13324 }
13325
13326 /*
13327 * Determine whether VARIADIC should be printed. We must do this first
13328 * since it affects the lookup rules in func_get_detail().
13329 *
13330 * We always print VARIADIC if the function has a merged variadic-array
13331 * argument. Note that this is always the case for functions taking a
13332 * VARIADIC argument type other than VARIADIC ANY. If we omitted VARIADIC
13333 * and printed the array elements as separate arguments, the call could
13334 * match a newer non-VARIADIC function.
13335 */
13336 if (use_variadic_p)
13337 {
13338 /* Parser should not have set funcvariadic unless fn is variadic */
13339 Assert(!has_variadic || OidIsValid(procform->provariadic));
13340 use_variadic = has_variadic;
13341 *use_variadic_p = use_variadic;
13342 }
13343 else
13344 {
13345 Assert(!has_variadic);
13346 use_variadic = false;
13347 }
13348
13349 /*
13350 * The idea here is to schema-qualify only if the parser would fail to
13351 * resolve the correct function given the unqualified func name with the
13352 * specified argtypes and VARIADIC flag. But if we already decided to
13353 * force qualification, then we can skip the lookup and pretend we didn't
13354 * find it.
13355 */
13356 if (!force_qualify)
13357 p_result = func_get_detail(list_make1(makeString(proname)),
13358 NIL, argnames, nargs, argtypes,
13359 !use_variadic, true, false,
13360 &fgc_flags,
13361 &p_funcid, &p_rettype,
13362 &p_retset, &p_nvargs, &p_vatype,
13363 &p_true_typeids, NULL);
13364 else
13365 {
13366 p_result = FUNCDETAIL_NOTFOUND;
13367 p_funcid = InvalidOid;
13368 }
13369
13370 if ((p_result == FUNCDETAIL_NORMAL ||
13371 p_result == FUNCDETAIL_AGGREGATE ||
13372 p_result == FUNCDETAIL_WINDOWFUNC) &&
13373 p_funcid == funcid)
13374 nspname = NULL;
13375 else
13376 nspname = get_namespace_name_or_temp(procform->pronamespace);
13377
13378 result = quote_qualified_identifier(nspname, proname);
13379
13380 ReleaseSysCache(proctup);
13381
13382 return result;
13383}
13384
13385/*
13386 * generate_operator_name
13387 * Compute the name to display for an operator specified by OID,
13388 * given that it is being called with the specified actual arg types.
13389 * (Arg types matter because of ambiguous-operator resolution rules.
13390 * Pass InvalidOid for unused arg of a unary operator.)
13391 *
13392 * The result includes all necessary quoting and schema-prefixing,
13393 * plus the OPERATOR() decoration needed to use a qualified operator name
13394 * in an expression.
13395 */
13396static char *
13397generate_operator_name(Oid operid, Oid arg1, Oid arg2)
13398{
13399 StringInfoData buf;
13400 HeapTuple opertup;
13401 Form_pg_operator operform;
13402 char *oprname;
13403 char *nspname;
13404 Operator p_result;
13405
13406 initStringInfo(&buf);
13407
13408 opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operid));
13409 if (!HeapTupleIsValid(opertup))
13410 elog(ERROR, "cache lookup failed for operator %u", operid);
13411 operform = (Form_pg_operator) GETSTRUCT(opertup);
13412 oprname = NameStr(operform->oprname);
13413
13414 /*
13415 * The idea here is to schema-qualify only if the parser would fail to
13416 * resolve the correct operator given the unqualified op name with the
13417 * specified argtypes.
13418 */
13419 switch (operform->oprkind)
13420 {
13421 case 'b':
13422 p_result = oper(NULL, list_make1(makeString(oprname)), arg1, arg2,
13423 true, -1);
13424 break;
13425 case 'l':
13426 p_result = left_oper(NULL, list_make1(makeString(oprname)), arg2,
13427 true, -1);
13428 break;
13429 default:
13430 elog(ERROR, "unrecognized oprkind: %d", operform->oprkind);
13431 p_result = NULL; /* keep compiler quiet */
13432 break;
13433 }
13434
13435 if (p_result != NULL && oprid(p_result) == operid)
13436 nspname = NULL;
13437 else
13438 {
13439 nspname = get_namespace_name_or_temp(operform->oprnamespace);
13440 appendStringInfo(&buf, "OPERATOR(%s.", quote_identifier(nspname));
13441 }
13442
13443 appendStringInfoString(&buf, oprname);
13444
13445 if (nspname)
13446 appendStringInfoChar(&buf, ')');
13447
13448 if (p_result != NULL)
13449 ReleaseSysCache(p_result);
13450
13451 ReleaseSysCache(opertup);
13452
13453 return buf.data;
13454}
13455
13456/*
13457 * generate_operator_clause --- generate a binary-operator WHERE clause
13458 *
13459 * This is used for internally-generated-and-executed SQL queries, where
13460 * precision is essential and readability is secondary. The basic
13461 * requirement is to append "leftop op rightop" to buf, where leftop and
13462 * rightop are given as strings and are assumed to yield types leftoptype
13463 * and rightoptype; the operator is identified by OID. The complexity
13464 * comes from needing to be sure that the parser will select the desired
13465 * operator when the query is parsed. We always name the operator using
13466 * OPERATOR(schema.op) syntax, so as to avoid search-path uncertainties.
13467 * We have to emit casts too, if either input isn't already the input type
13468 * of the operator; else we are at the mercy of the parser's heuristics for
13469 * ambiguous-operator resolution. The caller must ensure that leftop and
13470 * rightop are suitable arguments for a cast operation; it's best to insert
13471 * parentheses if they aren't just variables or parameters.
13472 */
13473void
13474generate_operator_clause(StringInfo buf,
13475 const char *leftop, Oid leftoptype,
13476 Oid opoid,
13477 const char *rightop, Oid rightoptype)
13478{
13479 HeapTuple opertup;
13480 Form_pg_operator operform;
13481 char *oprname;
13482 char *nspname;
13483
13484 opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(opoid));
13485 if (!HeapTupleIsValid(opertup))
13486 elog(ERROR, "cache lookup failed for operator %u", opoid);
13487 operform = (Form_pg_operator) GETSTRUCT(opertup);
13488 Assert(operform->oprkind == 'b');
13489 oprname = NameStr(operform->oprname);
13490
13491 nspname = get_namespace_name(operform->oprnamespace);
13492
13493 appendStringInfoString(buf, leftop);
13494 if (leftoptype != operform->oprleft)
13495 add_cast_to(buf, operform->oprleft);
13496 appendStringInfo(buf, " OPERATOR(%s.", quote_identifier(nspname));
13497 appendStringInfoString(buf, oprname);
13498 appendStringInfo(buf, ") %s", rightop);
13499 if (rightoptype != operform->oprright)
13500 add_cast_to(buf, operform->oprright);
13501
13502 ReleaseSysCache(opertup);
13503}
13504
13505/*
13506 * Add a cast specification to buf. We spell out the type name the hard way,
13507 * intentionally not using format_type_be(). This is to avoid corner cases
13508 * for CHARACTER, BIT, and perhaps other types, where specifying the type
13509 * using SQL-standard syntax results in undesirable data truncation. By
13510 * doing it this way we can be certain that the cast will have default (-1)
13511 * target typmod.
13512 */
13513static void
13514add_cast_to(StringInfo buf, Oid typid)
13515{
13516 HeapTuple typetup;
13517 Form_pg_type typform;
13518 char *typname;
13519 char *nspname;
13520
13521 typetup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
13522 if (!HeapTupleIsValid(typetup))
13523 elog(ERROR, "cache lookup failed for type %u", typid);
13524 typform = (Form_pg_type) GETSTRUCT(typetup);
13525
13526 typname = NameStr(typform->typname);
13527 nspname = get_namespace_name_or_temp(typform->typnamespace);
13528
13529 appendStringInfo(buf, "::%s.%s",
13530 quote_identifier(nspname), quote_identifier(typname));
13531
13532 ReleaseSysCache(typetup);
13533}
13534
13535/*
13536 * generate_qualified_type_name
13537 * Compute the name to display for a type specified by OID
13538 *
13539 * This is different from format_type_be() in that we unconditionally
13540 * schema-qualify the name. That also means no special syntax for
13541 * SQL-standard type names ... although in current usage, this should
13542 * only get used for domains, so such cases wouldn't occur anyway.
13543 */
13544static char *
13545generate_qualified_type_name(Oid typid)
13546{
13547 HeapTuple tp;
13548 Form_pg_type typtup;
13549 char *typname;
13550 char *nspname;
13551 char *result;
13552
13553 tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
13554 if (!HeapTupleIsValid(tp))
13555 elog(ERROR, "cache lookup failed for type %u", typid);
13556 typtup = (Form_pg_type) GETSTRUCT(tp);
13557 typname = NameStr(typtup->typname);
13558
13559 nspname = get_namespace_name_or_temp(typtup->typnamespace);
13560 if (!nspname)
13561 elog(ERROR, "cache lookup failed for namespace %u",
13562 typtup->typnamespace);
13563
13564 result = quote_qualified_identifier(nspname, typname);
13565
13566 ReleaseSysCache(tp);
13567
13568 return result;
13569}
13570
13571/*
13572 * generate_collation_name
13573 * Compute the name to display for a collation specified by OID
13574 *
13575 * The result includes all necessary quoting and schema-prefixing.
13576 */
13577char *
13578generate_collation_name(Oid collid)
13579{
13580 HeapTuple tp;
13581 Form_pg_collation colltup;
13582 char *collname;
13583 char *nspname;
13584 char *result;
13585
13586 tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(collid));
13587 if (!HeapTupleIsValid(tp))
13588 elog(ERROR, "cache lookup failed for collation %u", collid);
13589 colltup = (Form_pg_collation) GETSTRUCT(tp);
13590 collname = NameStr(colltup->collname);
13591
13592 if (!CollationIsVisible(collid))
13593 nspname = get_namespace_name_or_temp(colltup->collnamespace);
13594 else
13595 nspname = NULL;
13596
13597 result = quote_qualified_identifier(nspname, collname);
13598
13599 ReleaseSysCache(tp);
13600
13601 return result;
13602}
13603
13604/*
13605 * Given a C string, produce a TEXT datum.
13606 *
13607 * We assume that the input was palloc'd and may be freed.
13608 */
13609static text *
13610string_to_text(char *str)
13611{
13612 text *result;
13613
13614 result = cstring_to_text(str);
13615 pfree(str);
13616 return result;
13617}
13618
13619/*
13620 * Generate a C string representing a relation options from text[] datum.
13621 */
13622static void
13623get_reloptions(StringInfo buf, Datum reloptions)
13624{
13625 Datum *options;
13626 int noptions;
13627 int i;
13628
13629 deconstruct_array_builtin(DatumGetArrayTypeP(reloptions), TEXTOID,
13630 &options, NULL, &noptions);
13631
13632 for (i = 0; i < noptions; i++)
13633 {
13634 char *option = TextDatumGetCString(options[i]);
13635 char *name;
13636 char *separator;
13637 char *value;
13638
13639 /*
13640 * Each array element should have the form name=value. If the "=" is
13641 * missing for some reason, treat it like an empty value.
13642 */
13643 name = option;
13644 separator = strchr(option, '=');
13645 if (separator)
13646 {
13647 *separator = '\0';
13648 value = separator + 1;
13649 }
13650 else
13651 value = "";
13652
13653 if (i > 0)
13654 appendStringInfoString(buf, ", ");
13655 appendStringInfo(buf, "%s=", quote_identifier(name));
13656
13657 /*
13658 * In general we need to quote the value; but to avoid unnecessary
13659 * clutter, do not quote if it is an identifier that would not need
13660 * quoting. (We could also allow numbers, but that is a bit trickier
13661 * than it looks --- for example, are leading zeroes significant? We
13662 * don't want to assume very much here about what custom reloptions
13663 * might mean.)
13664 */
13665 if (quote_identifier(value) == value)
13666 appendStringInfoString(buf, value);
13667 else
13668 simple_quote_literal(buf, value);
13669
13670 pfree(option);
13671 }
13672}
13673
13674/*
13675 * Generate a C string representing a relation's reloptions, or NULL if none.
13676 */
13677static char *
13678flatten_reloptions(Oid relid)
13679{
13680 char *result = NULL;
13681 HeapTuple tuple;
13682 Datum reloptions;
13683 bool isnull;
13684
13685 tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
13686 if (!HeapTupleIsValid(tuple))
13687 elog(ERROR, "cache lookup failed for relation %u", relid);
13688
13689 reloptions = SysCacheGetAttr(RELOID, tuple,
13690 Anum_pg_class_reloptions, &isnull);
13691 if (!isnull)
13692 {
13693 StringInfoData buf;
13694
13695 initStringInfo(&buf);
13696 get_reloptions(&buf, reloptions);
13697
13698 result = buf.data;
13699 }
13700
13701 ReleaseSysCache(tuple);
13702
13703 return result;
13704}
13705
13706/*
13707 * get_range_partbound_string
13708 * A C string representation of one range partition bound
13709 */
13710char *
13711get_range_partbound_string(List *bound_datums)
13712{
13713 deparse_context context;
13714 StringInfoData buf;
13715 ListCell *cell;
13716 char *sep;
13717
13718 initStringInfo(&buf);
13719 memset(&context, 0, sizeof(deparse_context));
13720 context.buf = &buf;
13721
13722 appendStringInfoChar(&buf, '(');
13723 sep = "";
13724 foreach(cell, bound_datums)
13725 {
13726 PartitionRangeDatum *datum =
13727 lfirst_node(PartitionRangeDatum, cell);
13728
13729 appendStringInfoString(&buf, sep);
13730 if (datum->kind == PARTITION_RANGE_DATUM_MINVALUE)
13731 appendStringInfoString(&buf, "MINVALUE");
13732 else if (datum->kind == PARTITION_RANGE_DATUM_MAXVALUE)
13733 appendStringInfoString(&buf, "MAXVALUE");
13734 else
13735 {
13736 Const *val = castNode(Const, datum->value);
13737
13738 get_const_expr(val, &context, -1);
13739 }
13740 sep = ", ";
13741 }
13742 appendStringInfoChar(&buf, ')');
13743
13744 return buf.data;
13745}
GetIndexAmRoutine
IndexAmRoutine * GetIndexAmRoutine(Oid amhandler)
Definition: amapi.c:33
ARR_NDIM
#define ARR_NDIM(a)
Definition: array.h:290
ARR_DATA_PTR
#define ARR_DATA_PTR(a)
Definition: array.h:322
DatumGetArrayTypeP
#define DatumGetArrayTypeP(X)
Definition: array.h:261
ARR_ELEMTYPE
#define ARR_ELEMTYPE(a)
Definition: array.h:292
ARR_DIMS
#define ARR_DIMS(a)
Definition: array.h:294
ARR_HASNULL
#define ARR_HASNULL(a)
Definition: array.h:291
ARR_LBOUND
#define ARR_LBOUND(a)
Definition: array.h:296
accumArrayResult
ArrayBuildState * accumArrayResult(ArrayBuildState *astate, Datum dvalue, bool disnull, Oid element_type, MemoryContext rcontext)
Definition: arrayfuncs.c:5351
array_ref
Datum array_ref(ArrayType *array, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
Definition: arrayfuncs.c:3147
deconstruct_array_builtin
void deconstruct_array_builtin(const ArrayType *array, Oid elmtype, Datum **elemsp, bool **nullsp, int *nelemsp)
Definition: arrayfuncs.c:3698
makeArrayResult
Datum makeArrayResult(ArrayBuildState *astate, MemoryContext rcontext)
Definition: arrayfuncs.c:5421
AttrNumber
int16 AttrNumber
Definition: attnum.h:21
InvalidAttrNumber
#define InvalidAttrNumber
Definition: attnum.h:23
get_tablespace_name
char * get_tablespace_name(Oid spc_oid)
Definition: tablespace.c:1472
bms_make_singleton
Bitmapset * bms_make_singleton(int x)
Definition: bitmapset.c:216
bms_is_subset
bool bms_is_subset(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:412
bms_is_member
bool bms_is_member(int x, const Bitmapset *a)
Definition: bitmapset.c:510
bms_add_member
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:815
bms_union
Bitmapset * bms_union(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:251
bms_is_empty
#define bms_is_empty(a)
Definition: bitmapset.h:118
TextDatumGetCString
#define TextDatumGetCString(d)
Definition: builtins.h:98
NameStr
#define NameStr(name)
Definition: c.h:756
bits16
uint16 bits16
Definition: c.h:551
Name
NameData * Name
Definition: c.h:754
Max
#define Max(x, y)
Definition: c.h:1002
int16
int16_t int16
Definition: c.h:538
SQL_STR_DOUBLE
#define SQL_STR_DOUBLE(ch, escape_backslash)
Definition: c.h:1167
int32
int32_t int32
Definition: c.h:539
lengthof
#define lengthof(array)
Definition: c.h:792
Index
unsigned int Index
Definition: c.h:624
float4
float float4
Definition: c.h:639
OidIsValid
#define OidIsValid(objectId)
Definition: c.h:779
collid
Oid collid
Definition: collationcmds.c:700
ScanKeywordCategories
const uint8 ScanKeywordCategories[SCANKEYWORDS_NUM_KEYWORDS]
Definition: keywords.c:29
DEPENDENCY_AUTO
@ DEPENDENCY_AUTO
Definition: dependency.h:34
DEPENDENCY_INTERNAL
@ DEPENDENCY_INTERNAL
Definition: dependency.h:35
hash_search
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:952
hash_create
HTAB * hash_create(const char *tabname, int64 nelem, const HASHCTL *info, int flags)
Definition: dynahash.c:358
hash_destroy
void hash_destroy(HTAB *hashp)
Definition: dynahash.c:865
errcode
int errcode(int sqlerrcode)
Definition: elog.c:863
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:1080
ERROR
#define ERROR
Definition: elog.h:39
elog
#define elog(elevel,...)
Definition: elog.h:226
ereport
#define ereport(elevel,...)
Definition: elog.h:150
equal
bool equal(const void *a, const void *b)
Definition: equalfuncs.c:223
palloc0_array
#define palloc0_array(type, count)
Definition: fe_memutils.h:77
OidOutputFunctionCall
char * OidOutputFunctionCall(Oid functionId, Datum val)
Definition: fmgr.c:1763
PG_GETARG_OID
#define PG_GETARG_OID(n)
Definition: fmgr.h:275
PG_GETARG_TEXT_PP
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:309
DatumGetByteaPP
#define DatumGetByteaPP(X)
Definition: fmgr.h:291
DirectFunctionCall1
#define DirectFunctionCall1(func, arg1)
Definition: fmgr.h:682
PG_RETURN_NULL
#define PG_RETURN_NULL()
Definition: fmgr.h:345
PG_RETURN_TEXT_P
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:372
PG_RETURN_NAME
#define PG_RETURN_NAME(x)
Definition: fmgr.h:363
PG_GETARG_INT32
#define PG_GETARG_INT32(n)
Definition: fmgr.h:269
PG_GETARG_BOOL
#define PG_GETARG_BOOL(n)
Definition: fmgr.h:274
PG_RETURN_DATUM
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:353
PG_FUNCTION_ARGS
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
format_type_with_typemod
char * format_type_with_typemod(Oid type_oid, int32 typemod)
Definition: format_type.c:362
format_type_be
char * format_type_be(Oid type_oid)
Definition: format_type.c:343
get_func_trftypes
int get_func_trftypes(HeapTuple procTup, Oid **p_trftypes)
Definition: funcapi.c:1475
get_func_arg_info
int get_func_arg_info(HeapTuple procTup, Oid **p_argtypes, char ***p_argnames, char **p_argmodes)
Definition: funcapi.c:1379
get_expr_result_tupdesc
TupleDesc get_expr_result_tupdesc(Node *expr, bool noError)
Definition: funcapi.c:551
systable_endscan
void systable_endscan(SysScanDesc sysscan)
Definition: genam.c:603
systable_getnext
HeapTuple systable_getnext(SysScanDesc sysscan)
Definition: genam.c:514
systable_beginscan
SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
Definition: genam.c:388
GetConfigOptionFlags
int GetConfigOptionFlags(const char *name, bool missing_ok)
Definition: guc.c:4316
GUC_LIST_QUOTE
#define GUC_LIST_QUOTE
Definition: guc.h:215
Assert
Assert(PointerIsAligned(start, uint64))
str
const char * str
Definition: hashfn_unstable.h:254
heap_attisnull
bool heap_attisnull(HeapTuple tup, int attnum, TupleDesc tupleDesc)
Definition: heaptuple.c:456
HASH_STRINGS
#define HASH_STRINGS
Definition: hsearch.h:96
HASH_FIND
@ HASH_FIND
Definition: hsearch.h:113
HASH_ENTER
@ HASH_ENTER
Definition: hsearch.h:114
HASH_CONTEXT
#define HASH_CONTEXT
Definition: hsearch.h:102
HASH_ELEM
#define HASH_ELEM
Definition: hsearch.h:95
HeapTupleIsValid
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
htup_details.h
GETSTRUCT
static void * GETSTRUCT(const HeapTupleData *tuple)
Definition: htup_details.h:728
fastgetattr
static Datum fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition: htup_details.h:861
stmt
#define stmt
Definition: indent_codes.h:59
ident
#define ident
Definition: indent_codes.h:47
funcname
#define funcname
Definition: indent_codes.h:69
GetDefaultOpClass
Oid GetDefaultOpClass(Oid type_id, Oid am_id)
Definition: indexcmds.c:2344
val
long val
Definition: informix.c:689
value
static struct @171 value
a
int a
Definition: isn.c:73
j
int j
Definition: isn.c:78
i
int i
Definition: isn.c:77
if
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:81
ScanKeywords
PGDLLIMPORT const ScanKeywordList ScanKeywords
UNRESERVED_KEYWORD
#define UNRESERVED_KEYWORD
Definition: keywords.h:20
ScanKeywordLookup
int ScanKeywordLookup(const char *str, const ScanKeywordList *keywords)
Definition: kwlookup.c:38
lappend
List * lappend(List *list, void *datum)
Definition: list.c:339
list_copy_tail
List * list_copy_tail(const List *oldlist, int nskip)
Definition: list.c:1613
list_delete_first
List * list_delete_first(List *list)
Definition: list.c:943
list_concat
List * list_concat(List *list1, const List *list2)
Definition: list.c:561
list_copy
List * list_copy(const List *oldlist)
Definition: list.c:1573
lcons
List * lcons(void *datum, List *list)
Definition: list.c:495
list_free
void list_free(List *list)
Definition: list.c:1546
NoLock
#define NoLock
Definition: lockdefs.h:34
AccessShareLock
#define AccessShareLock
Definition: lockdefs.h:36
LockWaitSkip
@ LockWaitSkip
Definition: lockoptions.h:41
LockWaitError
@ LockWaitError
Definition: lockoptions.h:43
LCS_FORUPDATE
@ LCS_FORUPDATE
Definition: lockoptions.h:27
LCS_NONE
@ LCS_NONE
Definition: lockoptions.h:23
LCS_FORSHARE
@ LCS_FORSHARE
Definition: lockoptions.h:25
LCS_FORKEYSHARE
@ LCS_FORKEYSHARE
Definition: lockoptions.h:24
LCS_FORNOKEYUPDATE
@ LCS_FORNOKEYUPDATE
Definition: lockoptions.h:26
get_rel_name
char * get_rel_name(Oid relid)
Definition: lsyscache.c:2095
get_attnum
AttrNumber get_attnum(Oid relid, const char *attname)
Definition: lsyscache.c:951
get_opclass_input_type
Oid get_opclass_input_type(Oid opclass)
Definition: lsyscache.c:1331
type_is_rowtype
bool type_is_rowtype(Oid typid)
Definition: lsyscache.c:2822
getTypeOutputInfo
void getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
Definition: lsyscache.c:3074
get_attoptions
Datum get_attoptions(Oid relid, int16 attnum)
Definition: lsyscache.c:1063
get_rel_relkind
char get_rel_relkind(Oid relid)
Definition: lsyscache.c:2170
get_typcollation
Oid get_typcollation(Oid typid)
Definition: lsyscache.c:3223
get_language_name
char * get_language_name(Oid langoid, bool missing_ok)
Definition: lsyscache.c:1280
get_namespace_name_or_temp
char * get_namespace_name_or_temp(Oid nspid)
Definition: lsyscache.c:3557
get_constraint_name
char * get_constraint_name(Oid conoid)
Definition: lsyscache.c:1174
get_attname
char * get_attname(Oid relid, AttrNumber attnum, bool missing_ok)
Definition: lsyscache.c:920
get_rel_tablespace
Oid get_rel_tablespace(Oid relid)
Definition: lsyscache.c:2221
get_typ_typrelid
Oid get_typ_typrelid(Oid typid)
Definition: lsyscache.c:2898
get_base_element_type
Oid get_base_element_type(Oid typid)
Definition: lsyscache.c:2999
get_namespace_name
char * get_namespace_name(Oid nspid)
Definition: lsyscache.c:3533
get_type_category_preferred
void get_type_category_preferred(Oid typid, char *typcategory, bool *typispreferred)
Definition: lsyscache.c:2877
get_atttypetypmodcoll
void get_atttypetypmodcoll(Oid relid, AttrNumber attnum, Oid *typid, int32 *typmod, Oid *collid)
Definition: lsyscache.c:1036
makeAlias
Alias * makeAlias(const char *aliasname, List *colnames)
Definition: makefuncs.c:438
pg_mbcliplen
int pg_mbcliplen(const char *mbstr, int len, int limit)
Definition: mbutils.c:1084
pstrdup
char * pstrdup(const char *in)
Definition: mcxt.c:1759
pfree
void pfree(void *pointer)
Definition: mcxt.c:1594
palloc0
void * palloc0(Size size)
Definition: mcxt.c:1395
palloc
void * palloc(Size size)
Definition: mcxt.c:1365
CurrentMemoryContext
MemoryContext CurrentMemoryContext
Definition: mcxt.c:160
CHECK_FOR_INTERRUPTS
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:123
namein
Datum namein(PG_FUNCTION_ARGS)
Definition: name.c:48
CollationIsVisible
bool CollationIsVisible(Oid collid)
Definition: namespace.c:2474
RelationIsVisible
bool RelationIsVisible(Oid relid)
Definition: namespace.c:912
OpclassIsVisible
bool OpclassIsVisible(Oid opcid)
Definition: namespace.c:2221
makeRangeVarFromNameList
RangeVar * makeRangeVarFromNameList(const List *names)
Definition: namespace.c:3624
RangeVarGetRelid
#define RangeVarGetRelid(relation, lockmode, missing_ok)
Definition: namespace.h:98
generate_unaccent_rules.args
args
Definition: generate_unaccent_rules.py:288
generate_unaccent_rules.action
action
Definition: generate_unaccent_rules.py:287
exprType
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
exprIsLengthCoercion
bool exprIsLengthCoercion(const Node *expr, int32 *coercedTypmod)
Definition: nodeFuncs.c:557
exprTypmod
int32 exprTypmod(const Node *expr)
Definition: nodeFuncs.c:301
exprCollation
Oid exprCollation(const Node *expr)
Definition: nodeFuncs.c:821
strip_implicit_coercions
Node * strip_implicit_coercions(Node *node)
Definition: nodeFuncs.c:705
DO_AGGSPLIT_SKIPFINAL
#define DO_AGGSPLIT_SKIPFINAL(as)
Definition: nodes.h:396
IsA
#define IsA(nodeptr, _type_)
Definition: nodes.h:164
nodeTag
#define nodeTag(nodeptr)
Definition: nodes.h:139
DO_AGGSPLIT_COMBINE
#define DO_AGGSPLIT_COMBINE(as)
Definition: nodes.h:395
ONCONFLICT_NOTHING
@ ONCONFLICT_NOTHING
Definition: nodes.h:429
CMD_MERGE
@ CMD_MERGE
Definition: nodes.h:279
CMD_UTILITY
@ CMD_UTILITY
Definition: nodes.h:280
CMD_INSERT
@ CMD_INSERT
Definition: nodes.h:277
CMD_DELETE
@ CMD_DELETE
Definition: nodes.h:278
CMD_UPDATE
@ CMD_UPDATE
Definition: nodes.h:276
CMD_SELECT
@ CMD_SELECT
Definition: nodes.h:275
CMD_NOTHING
@ CMD_NOTHING
Definition: nodes.h:282
LIMIT_OPTION_WITH_TIES
@ LIMIT_OPTION_WITH_TIES
Definition: nodes.h:442
makeNode
#define makeNode(_type_)
Definition: nodes.h:161
castNode
#define castNode(_type_, nodeptr)
Definition: nodes.h:182
JOIN_FULL
@ JOIN_FULL
Definition: nodes.h:305
JOIN_INNER
@ JOIN_INNER
Definition: nodes.h:303
JOIN_RIGHT
@ JOIN_RIGHT
Definition: nodes.h:306
JOIN_LEFT
@ JOIN_LEFT
Definition: nodes.h:304
repalloc0_array
#define repalloc0_array(pointer, type, oldcount, count)
Definition: palloc.h:109
get_aggregate_argtypes
int get_aggregate_argtypes(Aggref *aggref, Oid *inputTypes)
Definition: parse_agg.c:2050
parse_agg.h
func_get_detail
FuncDetailCode func_get_detail(List *funcname, List *fargs, List *fargnames, int nargs, Oid *argtypes, bool expand_variadic, bool expand_defaults, bool include_out_arguments, int *fgc_flags, Oid *funcid, Oid *rettype, bool *retset, int *nvargs, Oid *vatype, Oid **true_typeids, List **argdefaults)
Definition: parse_func.c:1513
parse_func.h
FuncDetailCode
FuncDetailCode
Definition: parse_func.h:23
FUNCDETAIL_NORMAL
@ FUNCDETAIL_NORMAL
Definition: parse_func.h:26
FUNCDETAIL_WINDOWFUNC
@ FUNCDETAIL_WINDOWFUNC
Definition: parse_func.h:29
FUNCDETAIL_NOTFOUND
@ FUNCDETAIL_NOTFOUND
Definition: parse_func.h:24
FUNCDETAIL_AGGREGATE
@ FUNCDETAIL_AGGREGATE
Definition: parse_func.h:28
left_oper
Operator left_oper(ParseState *pstate, List *op, Oid arg, bool noError, int location)
Definition: parse_oper.c:521
oprid
Oid oprid(Operator op)
Definition: parse_oper.c:239
oper
Operator oper(ParseState *pstate, List *opname, Oid ltypeId, Oid rtypeId, bool noError, int location)
Definition: parse_oper.c:371
parse_oper.h
get_rte_attribute_name
char * get_rte_attribute_name(RangeTblEntry *rte, AttrNumber attnum)
Definition: parse_relation.c:3358
get_tle_by_resno
TargetEntry * get_tle_by_resno(List *tlist, AttrNumber resno)
Definition: parse_relation.c:3545
expandRTE
void expandRTE(RangeTblEntry *rte, int rtindex, int sublevels_up, VarReturningType returning_type, int location, bool include_dropped, List **colnames, List **colvars)
Definition: parse_relation.c:2751
parse_relation.h
FRAMEOPTION_END_CURRENT_ROW
#define FRAMEOPTION_END_CURRENT_ROW
Definition: parsenodes.h:619
FRAMEOPTION_END_OFFSET
#define FRAMEOPTION_END_OFFSET
Definition: parsenodes.h:630
FRAMEOPTION_EXCLUDE_CURRENT_ROW
#define FRAMEOPTION_EXCLUDE_CURRENT_ROW
Definition: parsenodes.h:624
GROUPING_SET_CUBE
@ GROUPING_SET_CUBE
Definition: parsenodes.h:1533
GROUPING_SET_SIMPLE
@ GROUPING_SET_SIMPLE
Definition: parsenodes.h:1531
GROUPING_SET_ROLLUP
@ GROUPING_SET_ROLLUP
Definition: parsenodes.h:1532
GROUPING_SET_SETS
@ GROUPING_SET_SETS
Definition: parsenodes.h:1534
GROUPING_SET_EMPTY
@ GROUPING_SET_EMPTY
Definition: parsenodes.h:1530
FKCONSTR_ACTION_RESTRICT
#define FKCONSTR_ACTION_RESTRICT
Definition: parsenodes.h:2820
SETOP_INTERSECT
@ SETOP_INTERSECT
Definition: parsenodes.h:2178
SETOP_UNION
@ SETOP_UNION
Definition: parsenodes.h:2177
SETOP_EXCEPT
@ SETOP_EXCEPT
Definition: parsenodes.h:2179
FRAMEOPTION_END_OFFSET_PRECEDING
#define FRAMEOPTION_END_OFFSET_PRECEDING
Definition: parsenodes.h:621
FRAMEOPTION_START_UNBOUNDED_PRECEDING
#define FRAMEOPTION_START_UNBOUNDED_PRECEDING
Definition: parsenodes.h:614
GetCTETargetList
#define GetCTETargetList(cte)
Definition: parsenodes.h:1736
FKCONSTR_ACTION_SETDEFAULT
#define FKCONSTR_ACTION_SETDEFAULT
Definition: parsenodes.h:2823
PARTITION_STRATEGY_HASH
@ PARTITION_STRATEGY_HASH
Definition: parsenodes.h:902
PARTITION_STRATEGY_LIST
@ PARTITION_STRATEGY_LIST
Definition: parsenodes.h:900
PARTITION_STRATEGY_RANGE
@ PARTITION_STRATEGY_RANGE
Definition: parsenodes.h:901
FRAMEOPTION_START_CURRENT_ROW
#define FRAMEOPTION_START_CURRENT_ROW
Definition: parsenodes.h:618
FKCONSTR_MATCH_SIMPLE
#define FKCONSTR_MATCH_SIMPLE
Definition: parsenodes.h:2828
RTE_JOIN
@ RTE_JOIN
Definition: parsenodes.h:1045
RTE_CTE
@ RTE_CTE
Definition: parsenodes.h:1049
RTE_NAMEDTUPLESTORE
@ RTE_NAMEDTUPLESTORE
Definition: parsenodes.h:1050
RTE_VALUES
@ RTE_VALUES
Definition: parsenodes.h:1048
RTE_SUBQUERY
@ RTE_SUBQUERY
Definition: parsenodes.h:1044
RTE_RESULT
@ RTE_RESULT
Definition: parsenodes.h:1051
RTE_FUNCTION
@ RTE_FUNCTION
Definition: parsenodes.h:1046
RTE_TABLEFUNC
@ RTE_TABLEFUNC
Definition: parsenodes.h:1047
RTE_GROUP
@ RTE_GROUP
Definition: parsenodes.h:1054
RTE_RELATION
@ RTE_RELATION
Definition: parsenodes.h:1043
FRAMEOPTION_START_OFFSET
#define FRAMEOPTION_START_OFFSET
Definition: parsenodes.h:628
PARTITION_RANGE_DATUM_MAXVALUE
@ PARTITION_RANGE_DATUM_MAXVALUE
Definition: parsenodes.h:954
PARTITION_RANGE_DATUM_MINVALUE
@ PARTITION_RANGE_DATUM_MINVALUE
Definition: parsenodes.h:952
FKCONSTR_MATCH_PARTIAL
#define FKCONSTR_MATCH_PARTIAL
Definition: parsenodes.h:2827
FRAMEOPTION_END_OFFSET_FOLLOWING
#define FRAMEOPTION_END_OFFSET_FOLLOWING
Definition: parsenodes.h:623
FRAMEOPTION_EXCLUDE_TIES
#define FRAMEOPTION_EXCLUDE_TIES
Definition: parsenodes.h:626
FRAMEOPTION_RANGE
#define FRAMEOPTION_RANGE
Definition: parsenodes.h:610
FRAMEOPTION_EXCLUDE_GROUP
#define FRAMEOPTION_EXCLUDE_GROUP
Definition: parsenodes.h:625
FKCONSTR_ACTION_CASCADE
#define FKCONSTR_ACTION_CASCADE
Definition: parsenodes.h:2821
FRAMEOPTION_GROUPS
#define FRAMEOPTION_GROUPS
Definition: parsenodes.h:612
FRAMEOPTION_BETWEEN
#define FRAMEOPTION_BETWEEN
Definition: parsenodes.h:613
FKCONSTR_ACTION_SETNULL
#define FKCONSTR_ACTION_SETNULL
Definition: parsenodes.h:2822
FRAMEOPTION_END_UNBOUNDED_FOLLOWING
#define FRAMEOPTION_END_UNBOUNDED_FOLLOWING
Definition: parsenodes.h:617
FRAMEOPTION_START_OFFSET_PRECEDING
#define FRAMEOPTION_START_OFFSET_PRECEDING
Definition: parsenodes.h:620
FRAMEOPTION_START_OFFSET_FOLLOWING
#define FRAMEOPTION_START_OFFSET_FOLLOWING
Definition: parsenodes.h:622
FRAMEOPTION_NONDEFAULT
#define FRAMEOPTION_NONDEFAULT
Definition: parsenodes.h:609
FKCONSTR_MATCH_FULL
#define FKCONSTR_MATCH_FULL
Definition: parsenodes.h:2826
FKCONSTR_ACTION_NOACTION
#define FKCONSTR_ACTION_NOACTION
Definition: parsenodes.h:2819
FRAMEOPTION_ROWS
#define FRAMEOPTION_ROWS
Definition: parsenodes.h:611
CTEMaterializeNever
@ CTEMaterializeNever
Definition: parsenodes.h:1671
CTEMaterializeAlways
@ CTEMaterializeAlways
Definition: parsenodes.h:1670
CTEMaterializeDefault
@ CTEMaterializeDefault
Definition: parsenodes.h:1669
rt_fetch
#define rt_fetch(rangetable_index, rangetable)
Definition: parsetree.h:31
get_partition_qual_relid
Expr * get_partition_qual_relid(Oid relid)
Definition: partcache.c:299
pg_aggregate.h
Form_pg_aggregate
FormData_pg_aggregate * Form_pg_aggregate
Definition: pg_aggregate.h:109
pg_am.h
Form_pg_am
FormData_pg_am * Form_pg_am
Definition: pg_am.h:48
attname
NameData attname
Definition: pg_attribute.h:41
attnum
int16 attnum
Definition: pg_attribute.h:74
Form_pg_attribute
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:202
pg_authid.h
Form_pg_authid
FormData_pg_authid * Form_pg_authid
Definition: pg_authid.h:56
arg
void * arg
Definition: pg_backup_utils.c:29
format
static char format
Definition: pg_basebackup.c:134
relname
NameData relname
Definition: pg_class.h:38
Form_pg_class
FormData_pg_class * Form_pg_class
Definition: pg_class.h:156
pg_collation.h
Form_pg_collation
FormData_pg_collation * Form_pg_collation
Definition: pg_collation.h:58
NAMEDATALEN
#define NAMEDATALEN
Definition: pg_config_manual.h:39
FUNC_MAX_ARGS
#define FUNC_MAX_ARGS
Definition: pg_config_manual.h:53
extractNotNullColumn
AttrNumber extractNotNullColumn(HeapTuple constrTup)
Definition: pg_constraint.c:702
pg_constraint.h
Form_pg_constraint
FormData_pg_constraint * Form_pg_constraint
Definition: pg_constraint.h:175
while
while(p+4<=pend)
Definition: pg_crc32c_sse42.c:58
encoding
int32 encoding
Definition: pg_database.h:41
pg_depend.h
Form_pg_depend
FormData_pg_depend * Form_pg_depend
Definition: pg_depend.h:72
Form_pg_index
FormData_pg_index * Form_pg_index
Definition: pg_index.h:70
pg_language.h
lfirst
#define lfirst(lc)
Definition: pg_list.h:172
llast
#define llast(l)
Definition: pg_list.h:198
lfirst_node
#define lfirst_node(type, lc)
Definition: pg_list.h:176
list_length
static int list_length(const List *l)
Definition: pg_list.h:152
linitial_node
#define linitial_node(type, l)
Definition: pg_list.h:181
NIL
#define NIL
Definition: pg_list.h:68
lsecond_node
#define lsecond_node(type, l)
Definition: pg_list.h:186
forboth
#define forboth(cell1, list1, cell2, list2)
Definition: pg_list.h:518
foreach_current_index
#define foreach_current_index(var_or_cell)
Definition: pg_list.h:403
lfirst_int
#define lfirst_int(lc)
Definition: pg_list.h:173
lthird
#define lthird(l)
Definition: pg_list.h:188
list_make1
#define list_make1(x1)
Definition: pg_list.h:212
linitial_int
#define linitial_int(l)
Definition: pg_list.h:179
for_each_cell
#define for_each_cell(cell, lst, initcell)
Definition: pg_list.h:438
for_each_from
#define for_each_from(cell, lst, N)
Definition: pg_list.h:414
list_nth
static void * list_nth(const List *list, int n)
Definition: pg_list.h:299
linitial
#define linitial(l)
Definition: pg_list.h:178
lsecond
#define lsecond(l)
Definition: pg_list.h:183
foreach_node
#define foreach_node(type, var, lst)
Definition: pg_list.h:496
forfour
#define forfour(cell1, list1, cell2, list2, cell3, list3, cell4, list4)
Definition: pg_list.h:575
list_head
static ListCell * list_head(const List *l)
Definition: pg_list.h:128
lnext
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:343
lfourth
#define lfourth(l)
Definition: pg_list.h:193
linitial_oid
#define linitial_oid(l)
Definition: pg_list.h:180
forfive
#define forfive(cell1, list1, cell2, list2, cell3, list3, cell4, list4, cell5, list5)
Definition: pg_list.h:588
lfirst_oid
#define lfirst_oid(lc)
Definition: pg_list.h:174
list_make2
#define list_make2(x1, x2)
Definition: pg_list.h:214
foreach_int
#define foreach_int(var, lst)
Definition: pg_list.h:470
list_cell_number
static int list_cell_number(const List *l, const ListCell *c)
Definition: pg_list.h:333
lthird_node
#define lthird_node(type, l)
Definition: pg_list.h:191
pg_opclass.h
Form_pg_opclass
FormData_pg_opclass * Form_pg_opclass
Definition: pg_opclass.h:83
pg_operator.h
Form_pg_operator
FormData_pg_operator * Form_pg_operator
Definition: pg_operator.h:83
pg_partitioned_table.h
Form_pg_partitioned_table
FormData_pg_partitioned_table * Form_pg_partitioned_table
Definition: pg_partitioned_table.h:65
pg_proc.h
Form_pg_proc
FormData_pg_proc * Form_pg_proc
Definition: pg_proc.h:136
proname
NameData proname
Definition: pg_proc.h:35
noptions
static size_t noptions
Definition: pg_recvlogical.c:60
options
static char ** options
Definition: pg_recvlogical.c:59
plan
#define plan(x)
Definition: pg_regress.c:161
pg_statistic_ext.h
Form_pg_statistic_ext
FormData_pg_statistic_ext * Form_pg_statistic_ext
Definition: pg_statistic_ext.h:69
buf
static char * buf
Definition: pg_test_fsync.c:72
pg_trigger.h
Form_pg_trigger
FormData_pg_trigger * Form_pg_trigger
Definition: pg_trigger.h:80
pg_type.h
Form_pg_type
FormData_pg_type * Form_pg_type
Definition: pg_type.h:261
typname
NameData typname
Definition: pg_type.h:41
pg_wchar.h
innerPlan
#define innerPlan(node)
Definition: plannodes.h:260
outerPlan
#define outerPlan(node)
Definition: plannodes.h:261
sprintf
#define sprintf
Definition: port.h:241
snprintf
#define snprintf
Definition: port.h:239
DatumGetBool
static bool DatumGetBool(Datum X)
Definition: postgres.h:100
PointerGetDatum
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:332
DatumGetName
static Name DatumGetName(Datum X)
Definition: postgres.h:370
DatumGetObjectId
static Oid DatumGetObjectId(Datum X)
Definition: postgres.h:252
ObjectIdGetDatum
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:262
Datum
uint64_t Datum
Definition: postgres.h:70
DatumGetPointer
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:322
DatumGetChar
static char DatumGetChar(Datum X)
Definition: postgres.h:122
CStringGetDatum
static Datum CStringGetDatum(const char *X)
Definition: postgres.h:360
Int32GetDatum
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:222
DatumGetInt16
static int16 DatumGetInt16(Datum X)
Definition: postgres.h:172
DatumGetInt32
static int32 DatumGetInt32(Datum X)
Definition: postgres.h:212
InvalidOid
#define InvalidOid
Definition: postgres_ext.h:37
Oid
unsigned int Oid
Definition: postgres_ext.h:32
e
e
Definition: preproc-init.c:82
string
char string[11]
Definition: preproc-type.c:52
IS_NOT_TRUE
@ IS_NOT_TRUE
Definition: primnodes.h:2001
IS_NOT_FALSE
@ IS_NOT_FALSE
Definition: primnodes.h:2001
IS_NOT_UNKNOWN
@ IS_NOT_UNKNOWN
Definition: primnodes.h:2001
IS_TRUE
@ IS_TRUE
Definition: primnodes.h:2001
IS_UNKNOWN
@ IS_UNKNOWN
Definition: primnodes.h:2001
IS_FALSE
@ IS_FALSE
Definition: primnodes.h:2001
ARRAY_SUBLINK
@ ARRAY_SUBLINK
Definition: primnodes.h:1035
ANY_SUBLINK
@ ANY_SUBLINK
Definition: primnodes.h:1031
MULTIEXPR_SUBLINK
@ MULTIEXPR_SUBLINK
Definition: primnodes.h:1034
CTE_SUBLINK
@ CTE_SUBLINK
Definition: primnodes.h:1036
EXPR_SUBLINK
@ EXPR_SUBLINK
Definition: primnodes.h:1033
ROWCOMPARE_SUBLINK
@ ROWCOMPARE_SUBLINK
Definition: primnodes.h:1032
ALL_SUBLINK
@ ALL_SUBLINK
Definition: primnodes.h:1030
EXISTS_SUBLINK
@ EXISTS_SUBLINK
Definition: primnodes.h:1029
JS_FORMAT_JSONB
@ JS_FORMAT_JSONB
Definition: primnodes.h:1665
JS_FORMAT_DEFAULT
@ JS_FORMAT_DEFAULT
Definition: primnodes.h:1663
JS_FORMAT_JSON
@ JS_FORMAT_JSON
Definition: primnodes.h:1664
IS_LEAST
@ IS_LEAST
Definition: primnodes.h:1528
IS_GREATEST
@ IS_GREATEST
Definition: primnodes.h:1527
TFT_XMLTABLE
@ TFT_XMLTABLE
Definition: primnodes.h:100
TFT_JSON_TABLE
@ TFT_JSON_TABLE
Definition: primnodes.h:101
BoolExprType
BoolExprType
Definition: primnodes.h:962
AND_EXPR
@ AND_EXPR
Definition: primnodes.h:963
OR_EXPR
@ OR_EXPR
Definition: primnodes.h:963
NOT_EXPR
@ NOT_EXPR
Definition: primnodes.h:963
JS_ENC_DEFAULT
@ JS_ENC_DEFAULT
Definition: primnodes.h:1651
JS_ENC_UTF32
@ JS_ENC_UTF32
Definition: primnodes.h:1654
JS_ENC_UTF16
@ JS_ENC_UTF16
Definition: primnodes.h:1653
XMLOPTION_DOCUMENT
@ XMLOPTION_DOCUMENT
Definition: primnodes.h:1617
SVFOP_CURRENT_CATALOG
@ SVFOP_CURRENT_CATALOG
Definition: primnodes.h:1574
SVFOP_LOCALTIME_N
@ SVFOP_LOCALTIME_N
Definition: primnodes.h:1567
SVFOP_CURRENT_TIMESTAMP
@ SVFOP_CURRENT_TIMESTAMP
Definition: primnodes.h:1564
SVFOP_LOCALTIME
@ SVFOP_LOCALTIME
Definition: primnodes.h:1566
SVFOP_CURRENT_TIMESTAMP_N
@ SVFOP_CURRENT_TIMESTAMP_N
Definition: primnodes.h:1565
SVFOP_CURRENT_ROLE
@ SVFOP_CURRENT_ROLE
Definition: primnodes.h:1570
SVFOP_USER
@ SVFOP_USER
Definition: primnodes.h:1572
SVFOP_CURRENT_SCHEMA
@ SVFOP_CURRENT_SCHEMA
Definition: primnodes.h:1575
SVFOP_LOCALTIMESTAMP_N
@ SVFOP_LOCALTIMESTAMP_N
Definition: primnodes.h:1569
SVFOP_CURRENT_DATE
@ SVFOP_CURRENT_DATE
Definition: primnodes.h:1561
SVFOP_CURRENT_TIME_N
@ SVFOP_CURRENT_TIME_N
Definition: primnodes.h:1563
SVFOP_CURRENT_TIME
@ SVFOP_CURRENT_TIME
Definition: primnodes.h:1562
SVFOP_LOCALTIMESTAMP
@ SVFOP_LOCALTIMESTAMP
Definition: primnodes.h:1568
SVFOP_CURRENT_USER
@ SVFOP_CURRENT_USER
Definition: primnodes.h:1571
SVFOP_SESSION_USER
@ SVFOP_SESSION_USER
Definition: primnodes.h:1573
PARAM_MULTIEXPR
@ PARAM_MULTIEXPR
Definition: primnodes.h:387
PARAM_EXTERN
@ PARAM_EXTERN
Definition: primnodes.h:384
PARAM_EXEC
@ PARAM_EXEC
Definition: primnodes.h:385
JSW_UNCONDITIONAL
@ JSW_UNCONDITIONAL
Definition: primnodes.h:1778
JSW_CONDITIONAL
@ JSW_CONDITIONAL
Definition: primnodes.h:1777
JSW_UNSPEC
@ JSW_UNSPEC
Definition: primnodes.h:1775
JSW_NONE
@ JSW_NONE
Definition: primnodes.h:1776
PARSER_IGNORE_NULLS
#define PARSER_IGNORE_NULLS
Definition: primnodes.h:589
IS_DOCUMENT
@ IS_DOCUMENT
Definition: primnodes.h:1612
IS_XMLFOREST
@ IS_XMLFOREST
Definition: primnodes.h:1607
IS_XMLCONCAT
@ IS_XMLCONCAT
Definition: primnodes.h:1605
IS_XMLPI
@ IS_XMLPI
Definition: primnodes.h:1609
IS_XMLPARSE
@ IS_XMLPARSE
Definition: primnodes.h:1608
IS_XMLSERIALIZE
@ IS_XMLSERIALIZE
Definition: primnodes.h:1611
IS_XMLROOT
@ IS_XMLROOT
Definition: primnodes.h:1610
IS_XMLELEMENT
@ IS_XMLELEMENT
Definition: primnodes.h:1606
VAR_RETURNING_OLD
@ VAR_RETURNING_OLD
Definition: primnodes.h:257
VAR_RETURNING_NEW
@ VAR_RETURNING_NEW
Definition: primnodes.h:258
VAR_RETURNING_DEFAULT
@ VAR_RETURNING_DEFAULT
Definition: primnodes.h:256
JsonBehaviorType
JsonBehaviorType
Definition: primnodes.h:1789
JSON_BEHAVIOR_DEFAULT
@ JSON_BEHAVIOR_DEFAULT
Definition: primnodes.h:1798
JSON_BEHAVIOR_FALSE
@ JSON_BEHAVIOR_FALSE
Definition: primnodes.h:1794
JSON_BEHAVIOR_NULL
@ JSON_BEHAVIOR_NULL
Definition: primnodes.h:1790
JSON_BEHAVIOR_EMPTY_ARRAY
@ JSON_BEHAVIOR_EMPTY_ARRAY
Definition: primnodes.h:1796
JSON_QUERY_OP
@ JSON_QUERY_OP
Definition: primnodes.h:1828
JSON_EXISTS_OP
@ JSON_EXISTS_OP
Definition: primnodes.h:1827
JSON_VALUE_OP
@ JSON_VALUE_OP
Definition: primnodes.h:1829
CoercionForm
CoercionForm
Definition: primnodes.h:765
COERCE_SQL_SYNTAX
@ COERCE_SQL_SYNTAX
Definition: primnodes.h:769
COERCE_IMPLICIT_CAST
@ COERCE_IMPLICIT_CAST
Definition: primnodes.h:768
COERCE_EXPLICIT_CAST
@ COERCE_EXPLICIT_CAST
Definition: primnodes.h:767
COERCE_EXPLICIT_CALL
@ COERCE_EXPLICIT_CALL
Definition: primnodes.h:766
OVERRIDING_SYSTEM_VALUE
@ OVERRIDING_SYSTEM_VALUE
Definition: primnodes.h:30
OVERRIDING_USER_VALUE
@ OVERRIDING_USER_VALUE
Definition: primnodes.h:29
IS_NULL
@ IS_NULL
Definition: primnodes.h:1977
IS_NOT_NULL
@ IS_NOT_NULL
Definition: primnodes.h:1977
JS_TYPE_ARRAY
@ JS_TYPE_ARRAY
Definition: primnodes.h:1749
JS_TYPE_OBJECT
@ JS_TYPE_OBJECT
Definition: primnodes.h:1748
JS_TYPE_SCALAR
@ JS_TYPE_SCALAR
Definition: primnodes.h:1750
MERGE_WHEN_NOT_MATCHED_BY_TARGET
@ MERGE_WHEN_NOT_MATCHED_BY_TARGET
Definition: primnodes.h:2023
MERGE_WHEN_NOT_MATCHED_BY_SOURCE
@ MERGE_WHEN_NOT_MATCHED_BY_SOURCE
Definition: primnodes.h:2022
MERGE_WHEN_MATCHED
@ MERGE_WHEN_MATCHED
Definition: primnodes.h:2021
OUTER_VAR
#define OUTER_VAR
Definition: primnodes.h:243
JSCTOR_JSON_SERIALIZE
@ JSCTOR_JSON_SERIALIZE
Definition: primnodes.h:1721
JSCTOR_JSON_ARRAYAGG
@ JSCTOR_JSON_ARRAYAGG
Definition: primnodes.h:1718
JSCTOR_JSON_PARSE
@ JSCTOR_JSON_PARSE
Definition: primnodes.h:1719
JSCTOR_JSON_OBJECT
@ JSCTOR_JSON_OBJECT
Definition: primnodes.h:1715
JSCTOR_JSON_SCALAR
@ JSCTOR_JSON_SCALAR
Definition: primnodes.h:1720
JSCTOR_JSON_ARRAY
@ JSCTOR_JSON_ARRAY
Definition: primnodes.h:1716
JSCTOR_JSON_OBJECTAGG
@ JSCTOR_JSON_OBJECTAGG
Definition: primnodes.h:1717
INNER_VAR
#define INNER_VAR
Definition: primnodes.h:242
INDEX_VAR
#define INDEX_VAR
Definition: primnodes.h:244
root
tree ctl root
Definition: radixtree.h:1857
stringToNode
void * stringToNode(const char *str)
Definition: read.c:90
RelationGetDescr
#define RelationGetDescr(relation)
Definition: rel.h:541
RelationGetRelationName
#define RelationGetRelationName(relation)
Definition: rel.h:549
AcquireRewriteLocks
void AcquireRewriteLocks(Query *parsetree, bool forExecute, bool forUpdatePushedDown)
Definition: rewriteHandler.c:148
getInsertSelectQuery
Query * getInsertSelectQuery(Query *parsetree, Query ***subquery_ptr)
Definition: rewriteManip.c:1090
ViewSelectRuleName
#define ViewSelectRuleName
Definition: rewriteSupport.h:18
pg_get_triggerdef_ext
Datum pg_get_triggerdef_ext(PG_FUNCTION_ARGS)
Definition: ruleutils.c:885
make_viewdef
static void make_viewdef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, int prettyFlags, int wrapColumn)
Definition: ruleutils.c:5542
removeStringInfoSpaces
static void removeStringInfoSpaces(StringInfo str)
Definition: ruleutils.c:9149
looks_like_function
static bool looks_like_function(Node *node)
Definition: ruleutils.c:10734
pg_get_partition_constraintdef
Datum pg_get_partition_constraintdef(PG_FUNCTION_ARGS)
Definition: ruleutils.c:2095
get_rtable_name
static char * get_rtable_name(int rtindex, deparse_context *context)
Definition: ruleutils.c:5136
pg_get_viewdef_wrap
Datum pg_get_viewdef_wrap(PG_FUNCTION_ARGS)
Definition: ruleutils.c:716
decompile_column_index_array
static int decompile_column_index_array(Datum column_index_array, Oid relId, bool withPeriod, StringInfo buf)
Definition: ruleutils.c:2620
set_relation_column_names
static void set_relation_column_names(deparse_namespace *dpns, RangeTblEntry *rte, deparse_columns *colinfo)
Definition: ruleutils.c:4378
appendContextKeyword
static void appendContextKeyword(deparse_context *context, const char *str, int indentBefore, int indentAfter, int indentPlus)
Definition: ruleutils.c:9095
deparse_context_for_plan_tree
List * deparse_context_for_plan_tree(PlannedStmt *pstmt, List *rtable_names)
Definition: ruleutils.c:3756
pg_get_statisticsobjdef_string
char * pg_get_statisticsobjdef_string(Oid statextid)
Definition: ruleutils.c:1626
pg_get_indexdef_ext
Datum pg_get_indexdef_ext(PG_FUNCTION_ARGS)
Definition: ruleutils.c:1198
set_using_names
static void set_using_names(deparse_namespace *dpns, Node *jtnode, List *parentUsing)
Definition: ruleutils.c:4213
find_recursive_union
static Plan * find_recursive_union(deparse_namespace *dpns, WorkTableScan *wtscan)
Definition: ruleutils.c:5236
string_to_text
static text * string_to_text(char *str)
Definition: ruleutils.c:13610
get_values_def
static void get_values_def(List *values_lists, deparse_context *context)
Definition: ruleutils.c:5727
PRETTYINDENT_LIMIT
#define PRETTYINDENT_LIMIT
Definition: ruleutils.c:85
pg_get_viewdef
Datum pg_get_viewdef(PG_FUNCTION_ARGS)
Definition: ruleutils.c:678
make_colname_unique
static char * make_colname_unique(char *colname, deparse_namespace *dpns, deparse_columns *colinfo)
Definition: ruleutils.c:4926
get_json_behavior
static void get_json_behavior(JsonBehavior *behavior, deparse_context *context, const char *on)
Definition: ruleutils.c:9186
get_simple_binary_op_name
static const char * get_simple_binary_op_name(OpExpr *expr)
Definition: ruleutils.c:8837
get_json_agg_constructor
static void get_json_agg_constructor(JsonConstructorExpr *ctor, deparse_context *context, const char *funcname, bool is_json_objectagg)
Definition: ruleutils.c:11801
pg_get_constraintdef
Datum pg_get_constraintdef(PG_FUNCTION_ARGS)
Definition: ruleutils.c:2145
set_deparse_for_query
static void set_deparse_for_query(deparse_namespace *dpns, Query *query, List *parent_namespaces)
Definition: ruleutils.c:4032
print_function_trftypes
static void print_function_trftypes(StringInfo buf, HeapTuple proctup)
Definition: ruleutils.c:3461
rsv_callback
void(* rsv_callback)(Node *node, deparse_context *context, void *callback_arg)
Definition: ruleutils.c:325
PRETTYINDENT_STD
#define PRETTYINDENT_STD
Definition: ruleutils.c:81
quote_qualified_identifier
char * quote_qualified_identifier(const char *qualifier, const char *ident)
Definition: ruleutils.c:13146
get_setop_query
static void get_setop_query(Node *setOp, Query *query, deparse_context *context)
Definition: ruleutils.c:6419
PRETTYINDENT_JOIN
#define PRETTYINDENT_JOIN
Definition: ruleutils.c:82
is_input_argument
static bool is_input_argument(int nth, const char *argmodes)
Definition: ruleutils.c:3449
get_query_def
static void get_query_def(Query *query, StringInfo buf, List *parentnamespace, TupleDesc resultDesc, bool colNamesVisible, int prettyFlags, int wrapColumn, int startIndent)
Definition: ruleutils.c:5627
get_tablesample_def
static void get_tablesample_def(TableSampleClause *tablesample, deparse_context *context)
Definition: ruleutils.c:12850
pg_get_functiondef
Datum pg_get_functiondef(PG_FUNCTION_ARGS)
Definition: ruleutils.c:2926
pg_get_function_result
Datum pg_get_function_result(PG_FUNCTION_ARGS)
Definition: ruleutils.c:3233
pg_get_indexdef
Datum pg_get_indexdef(PG_FUNCTION_ARGS)
Definition: ruleutils.c:1178
get_sublink_expr
static void get_sublink_expr(SubLink *sublink, deparse_context *context)
Definition: ruleutils.c:11853
get_name_for_var_field
static const char * get_name_for_var_field(Var *var, int fieldno, int levelsup, deparse_context *context)
Definition: ruleutils.c:8022
get_rte_alias
static void get_rte_alias(RangeTblEntry *rte, int varno, bool use_as, deparse_context *context)
Definition: ruleutils.c:12688
only_marker
#define only_marker(rte)
Definition: ruleutils.c:550
pg_get_function_arg_default
Datum pg_get_function_arg_default(PG_FUNCTION_ARGS)
Definition: ruleutils.c:3489
get_parameter
static void get_parameter(Param *param, deparse_context *context)
Definition: ruleutils.c:8692
build_colinfo_names_hash
static void build_colinfo_names_hash(deparse_columns *colinfo)
Definition: ruleutils.c:4981
pg_get_statisticsobjdef_expressions
Datum pg_get_statisticsobjdef_expressions(PG_FUNCTION_ARGS)
Definition: ruleutils.c:1837
get_delete_query_def
static void get_delete_query_def(Query *query, deparse_context *context)
Definition: ruleutils.c:7360
pg_get_ruledef
Datum pg_get_ruledef(PG_FUNCTION_ARGS)
Definition: ruleutils.c:560
get_json_table_columns
static void get_json_table_columns(TableFunc *tf, JsonTablePathScan *scan, deparse_context *context, bool showimplicit)
Definition: ruleutils.c:12109
PRETTYFLAG_INDENT
#define PRETTYFLAG_INDENT
Definition: ruleutils.c:89
get_column_alias_list
static void get_column_alias_list(deparse_columns *colinfo, deparse_context *context)
Definition: ruleutils.c:12759
pg_get_statisticsobjdef_columns
Datum pg_get_statisticsobjdef_columns(PG_FUNCTION_ARGS)
Definition: ruleutils.c:1636
pg_get_statisticsobjdef
Datum pg_get_statisticsobjdef(PG_FUNCTION_ARGS)
Definition: ruleutils.c:1608
add_to_names_hash
static void add_to_names_hash(deparse_columns *colinfo, const char *name)
Definition: ruleutils.c:5039
simple_quote_literal
static void simple_quote_literal(StringInfo buf, const char *val)
Definition: ruleutils.c:11826
colname_is_unique
static bool colname_is_unique(const char *colname, deparse_namespace *dpns, deparse_columns *colinfo)
Definition: ruleutils.c:4851
get_from_clause_coldeflist
static void get_from_clause_coldeflist(RangeTblFunction *rtfunc, deparse_columns *colinfo, deparse_context *context)
Definition: ruleutils.c:12799
pg_get_partkeydef_columns
char * pg_get_partkeydef_columns(Oid relid, bool pretty)
Definition: ruleutils.c:1923
get_from_clause
static void get_from_clause(Query *query, const char *prefix, deparse_context *context)
Definition: ruleutils.c:12303
deparse_context_for
List * deparse_context_for(const char *aliasname, Oid relid)
Definition: ruleutils.c:3711
get_func_sql_syntax
static bool get_func_sql_syntax(FuncExpr *expr, deparse_context *context)
Definition: ruleutils.c:11182
pg_get_partkeydef
Datum pg_get_partkeydef(PG_FUNCTION_ARGS)
Definition: ruleutils.c:1908
generate_qualified_relation_name
static char * generate_qualified_relation_name(Oid relid)
Definition: ruleutils.c:13246
set_simple_column_names
static void set_simple_column_names(deparse_namespace *dpns)
Definition: ruleutils.c:4101
get_json_expr_options
static void get_json_expr_options(JsonExpr *jsexpr, deparse_context *context, JsonBehaviorType default_behavior)
Definition: ruleutils.c:9224
pg_get_indexdef_columns
char * pg_get_indexdef_columns(Oid indexrelid, bool pretty)
Definition: ruleutils.c:1235
PRETTY_INDENT
#define PRETTY_INDENT(context)
Definition: ruleutils.c:102
PRETTYFLAG_PAREN
#define PRETTYFLAG_PAREN
Definition: ruleutils.c:88
get_rule_groupingset
static void get_rule_groupingset(GroupingSet *gset, List *targetlist, bool omit_parens, deparse_context *context)
Definition: ruleutils.c:6636
pg_get_indexdef_columns_extended
char * pg_get_indexdef_columns_extended(Oid indexrelid, bits16 flags)
Definition: ruleutils.c:1249
pg_get_indexdef_worker
static char * pg_get_indexdef_worker(Oid indexrelid, int colno, const Oid *excludeOps, bool attrsOnly, bool keysOnly, bool showTblSpc, bool inherits, int prettyFlags, bool missing_ok)
Definition: ruleutils.c:1270
pg_get_constraintdef_worker
static char * pg_get_constraintdef_worker(Oid constraintId, bool fullCommand, int prettyFlags, bool missing_ok)
Definition: ruleutils.c:2192
get_rule_expr_funccall
static void get_rule_expr_funccall(Node *node, deparse_context *context, bool showimplicit)
Definition: ruleutils.c:10711
generate_function_name
static char * generate_function_name(Oid funcid, int nargs, List *argnames, Oid *argtypes, bool has_variadic, bool *use_variadic_p, bool inGroupBy)
Definition: ruleutils.c:13290
expand_colnames_array_to
static void expand_colnames_array_to(deparse_columns *colinfo, int n)
Definition: ruleutils.c:4965
get_returning_clause
static void get_returning_clause(Query *query, deparse_context *context)
Definition: ruleutils.c:6380
set_deparse_context_plan
List * set_deparse_context_plan(List *dpcontext, Plan *plan, List *ancestors)
Definition: ruleutils.c:3828
find_param_generator
static SubPlan * find_param_generator(Param *param, deparse_context *context, int *column_p)
Definition: ruleutils.c:8574
add_cast_to
static void add_cast_to(StringInfo buf, Oid typid)
Definition: ruleutils.c:13514
get_special_variable
static void get_special_variable(Node *node, deparse_context *context, void *callback_arg)
Definition: ruleutils.c:7893
get_windowfunc_expr_helper
static void get_windowfunc_expr_helper(WindowFunc *wfunc, deparse_context *context, const char *funcname, const char *options, bool is_json_objectagg)
Definition: ruleutils.c:11064
get_rule_list_toplevel
static void get_rule_list_toplevel(List *lst, deparse_context *context, bool showimplicit)
Definition: ruleutils.c:10681
pg_get_statisticsobj_worker
static char * pg_get_statisticsobj_worker(Oid statextid, bool columns_only, bool missing_ok)
Definition: ruleutils.c:1653
deparse_columns_fetch
#define deparse_columns_fetch(rangetable_index, dpns)
Definition: ruleutils.c:312
get_json_constructor
static void get_json_constructor(JsonConstructorExpr *ctor, deparse_context *context, bool showimplicit)
Definition: ruleutils.c:11705
query_getrulebyoid
static const char *const query_getrulebyoid
Definition: ruleutils.c:334
get_json_path_spec
static void get_json_path_spec(Node *path_spec, deparse_context *context, bool showimplicit)
Definition: ruleutils.c:11648
printSubscripts
static void printSubscripts(SubscriptingRef *sbsref, deparse_context *context)
Definition: ruleutils.c:13032
find_param_generator_initplan
static SubPlan * find_param_generator_initplan(Param *param, Plan *plan, int *column_p)
Definition: ruleutils.c:8671
pop_ancestor_plan
static void pop_ancestor_plan(deparse_namespace *dpns, deparse_namespace *save_dpns)
Definition: ruleutils.c:5334
get_window_frame_options
static void get_window_frame_options(int frameOptions, Node *startOffset, Node *endOffset, deparse_context *context)
Definition: ruleutils.c:6843
get_rule_expr_paren
static void get_rule_expr_paren(Node *node, deparse_context *context, bool showimplicit, Node *parentNode)
Definition: ruleutils.c:9168
quote_all_identifiers
bool quote_all_identifiers
Definition: ruleutils.c:339
get_agg_expr
static void get_agg_expr(Aggref *aggref, deparse_context *context, Aggref *original_aggref)
Definition: ruleutils.c:10899
get_const_collation
static void get_const_collation(Const *constval, deparse_context *context)
Definition: ruleutils.c:11628
get_target_list
static void get_target_list(List *targetList, deparse_context *context)
Definition: ruleutils.c:6244
plan_getrulebyoid
static SPIPlanPtr plan_getrulebyoid
Definition: ruleutils.c:333
get_json_table_nested_columns
static void get_json_table_nested_columns(TableFunc *tf, JsonTablePlan *plan, deparse_context *context, bool showimplicit, bool needcomma)
Definition: ruleutils.c:12077
deparse_expression_pretty
static char * deparse_expression_pretty(Node *expr, List *dpcontext, bool forceprefix, bool showimplicit, int prettyFlags, int startIndent)
Definition: ruleutils.c:3675
pg_get_ruledef_ext
Datum pg_get_ruledef_ext(PG_FUNCTION_ARGS)
Definition: ruleutils.c:578
pg_get_indexdef_string
char * pg_get_indexdef_string(Oid indexrelid)
Definition: ruleutils.c:1225
get_insert_query_def
static void get_insert_query_def(Query *query, deparse_context *context)
Definition: ruleutils.c:6944
pg_get_querydef
char * pg_get_querydef(Query *query, bool pretty)
Definition: ruleutils.c:1588
print_function_sqlbody
static void print_function_sqlbody(StringInfo buf, HeapTuple proctup)
Definition: ruleutils.c:3559
has_dangerous_join_using
static bool has_dangerous_join_using(deparse_namespace *dpns, Node *jtnode)
Definition: ruleutils.c:4143
quote_identifier
const char * quote_identifier(const char *ident)
Definition: ruleutils.c:13062
get_rule_sortgroupclause
static Node * get_rule_sortgroupclause(Index ref, List *tlist, bool force_colno, deparse_context *context)
Definition: ruleutils.c:6567
pg_get_viewdef_worker
static char * pg_get_viewdef_worker(Oid viewoid, int prettyFlags, int wrapColumn)
Definition: ruleutils.c:789
push_ancestor_plan
static void push_ancestor_plan(deparse_namespace *dpns, ListCell *ancestor_cell, deparse_namespace *save_dpns)
Definition: ruleutils.c:5313
plan_getviewrule
static SPIPlanPtr plan_getviewrule
Definition: ruleutils.c:335
WRAP_COLUMN_DEFAULT
#define WRAP_COLUMN_DEFAULT
Definition: ruleutils.c:98
flatten_reloptions
static char * flatten_reloptions(Oid relid)
Definition: ruleutils.c:13678
pg_get_expr_worker
static text * pg_get_expr_worker(text *expr, Oid relid, int prettyFlags)
Definition: ruleutils.c:2709
processIndirection
static Node * processIndirection(Node *node, deparse_context *context)
Definition: ruleutils.c:12954
get_agg_combine_expr
static void get_agg_combine_expr(Node *node, deparse_context *context, void *callback_arg)
Definition: ruleutils.c:11037
PRETTY_PAREN
#define PRETTY_PAREN(context)
Definition: ruleutils.c:101
pg_get_triggerdef
Datum pg_get_triggerdef(PG_FUNCTION_ARGS)
Definition: ruleutils.c:871
select_rtable_names_for_explain
List * select_rtable_names_for_explain(List *rtable, Bitmapset *rels_used)
Definition: ruleutils.c:3858
pg_get_function_sqlbody
Datum pg_get_function_sqlbody(PG_FUNCTION_ARGS)
Definition: ruleutils.c:3613
pg_get_expr
Datum pg_get_expr(PG_FUNCTION_ARGS)
Definition: ruleutils.c:2674
generate_qualified_type_name
static char * generate_qualified_type_name(Oid typid)
Definition: ruleutils.c:13545
get_xmltable
static void get_xmltable(TableFunc *tf, deparse_context *context, bool showimplicit)
Definition: ruleutils.c:11978
get_utility_query_def
static void get_utility_query_def(Query *query, deparse_context *context)
Definition: ruleutils.c:7566
get_relation_name
static char * get_relation_name(Oid relid)
Definition: ruleutils.c:13166
pg_get_expr_ext
Datum pg_get_expr_ext(PG_FUNCTION_ARGS)
Definition: ruleutils.c:2691
get_rule_windowclause
static void get_rule_windowclause(Query *query, deparse_context *context)
Definition: ruleutils.c:6754
get_rule_windowspec
static void get_rule_windowspec(WindowClause *wc, List *targetList, deparse_context *context)
Definition: ruleutils.c:6786
get_json_returning
static void get_json_returning(JsonReturning *returning, StringInfo buf, bool json_format_by_default)
Definition: ruleutils.c:11685
pg_get_viewdef_name_ext
Datum pg_get_viewdef_name_ext(PG_FUNCTION_ARGS)
Definition: ruleutils.c:761
find_param_referent
static Node * find_param_referent(Param *param, deparse_context *context, deparse_namespace **dpns_p, ListCell **ancestor_cell_p)
Definition: ruleutils.c:8460
get_rule_orderby
static void get_rule_orderby(List *orderList, List *targetList, bool force_colno, deparse_context *context)
Definition: ruleutils.c:6696
pop_child_plan
static void pop_child_plan(deparse_namespace *dpns, deparse_namespace *save_dpns)
Definition: ruleutils.c:5283
generate_collation_name
char * generate_collation_name(Oid collid)
Definition: ruleutils.c:13578
pg_get_constraintdef_command
char * pg_get_constraintdef_command(Oid constraintId)
Definition: ruleutils.c:2183
pg_get_partconstrdef_string
char * pg_get_partconstrdef_string(Oid partitionId, char *aliasname)
Definition: ruleutils.c:2127
set_join_column_names
static void set_join_column_names(deparse_namespace *dpns, RangeTblEntry *rte, deparse_columns *colinfo)
Definition: ruleutils.c:4581
pg_get_constraintdef_ext
Datum pg_get_constraintdef_ext(PG_FUNCTION_ARGS)
Definition: ruleutils.c:2162
set_rtable_names
static void set_rtable_names(deparse_namespace *dpns, List *parent_namespaces, Bitmapset *rels_used)
Definition: ruleutils.c:3887
get_window_frame_options_for_explain
char * get_window_frame_options_for_explain(int frameOptions, Node *startOffset, Node *endOffset, List *dpcontext, bool forceprefix)
Definition: ruleutils.c:6912
get_update_query_targetlist_def
static void get_update_query_targetlist_def(Query *query, List *targetList, deparse_context *context, RangeTblEntry *rte)
Definition: ruleutils.c:7208
get_rule_expr
static void get_rule_expr(Node *node, deparse_context *context, bool showimplicit)
Definition: ruleutils.c:9265
pg_get_viewdef_ext
Datum pg_get_viewdef_ext(PG_FUNCTION_ARGS)
Definition: ruleutils.c:697
pg_get_partkeydef_worker
static char * pg_get_partkeydef_worker(Oid relid, int prettyFlags, bool attrsOnly, bool missing_ok)
Definition: ruleutils.c:1936
get_oper_expr
static void get_oper_expr(OpExpr *expr, deparse_context *context)
Definition: ruleutils.c:10763
pg_get_function_identity_arguments
Datum pg_get_function_identity_arguments(PG_FUNCTION_ARGS)
Definition: ruleutils.c:3208
pg_get_triggerdef_worker
static char * pg_get_triggerdef_worker(Oid trigid, bool pretty)
Definition: ruleutils.c:900
GET_PRETTY_FLAGS
#define GET_PRETTY_FLAGS(pretty)
Definition: ruleutils.c:93
get_reloptions
static void get_reloptions(StringInfo buf, Datum reloptions)
Definition: ruleutils.c:13623
get_func_expr
static void get_func_expr(FuncExpr *expr, deparse_context *context, bool showimplicit)
Definition: ruleutils.c:10803
get_const_expr
static void get_const_expr(Const *constval, deparse_context *context, int showtype)
Definition: ruleutils.c:11498
deparse_expression
char * deparse_expression(Node *expr, List *dpcontext, bool forceprefix, bool showimplicit)
Definition: ruleutils.c:3648
generate_operator_clause
void generate_operator_clause(StringInfo buf, const char *leftop, Oid leftoptype, Oid opoid, const char *rightop, Oid rightoptype)
Definition: ruleutils.c:13474
make_ruledef
static void make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, int prettyFlags)
Definition: ruleutils.c:5350
query_getviewrule
static const char *const query_getviewrule
Definition: ruleutils.c:336
pg_get_ruledef_worker
static char * pg_get_ruledef_worker(Oid ruleoid, int prettyFlags)
Definition: ruleutils.c:597
print_function_arguments
static int print_function_arguments(StringInfo buf, HeapTuple proctup, bool print_table_args, bool print_defaults)
Definition: ruleutils.c:3301
identify_join_columns
static void identify_join_columns(JoinExpr *j, RangeTblEntry *jrte, deparse_columns *colinfo)
Definition: ruleutils.c:5068
print_function_rettype
static void print_function_rettype(StringInfo buf, HeapTuple proctup)
Definition: ruleutils.c:3263
generate_opclass_name
char * generate_opclass_name(Oid opclass)
Definition: ruleutils.c:12932
set_deparse_plan
static void set_deparse_plan(deparse_namespace *dpns, Plan *plan)
Definition: ruleutils.c:5155
get_merge_query_def
static void get_merge_query_def(Query *query, deparse_context *context)
Definition: ruleutils.c:7407
resolve_special_varno
static void resolve_special_varno(Node *node, deparse_context *context, rsv_callback callback, void *callback_arg)
Definition: ruleutils.c:7914
get_json_format
static void get_json_format(JsonFormat *format, StringInfo buf)
Definition: ruleutils.c:11660
get_range_partbound_string
char * get_range_partbound_string(List *bound_datums)
Definition: ruleutils.c:13711
get_tablefunc
static void get_tablefunc(TableFunc *tf, deparse_context *context, bool showimplicit)
Definition: ruleutils.c:12284
get_rule_expr_toplevel
static void get_rule_expr_toplevel(Node *node, deparse_context *context, bool showimplicit)
Definition: ruleutils.c:10663
get_simple_values_rte
static RangeTblEntry * get_simple_values_rte(Query *query, TupleDesc resultDesc)
Definition: ruleutils.c:6042
get_coercion_expr
static void get_coercion_expr(Node *arg, deparse_context *context, Oid resulttype, int32 resulttypmod, Node *parentNode)
Definition: ruleutils.c:11434
push_child_plan
static void push_child_plan(deparse_namespace *dpns, Plan *plan, deparse_namespace *save_dpns)
Definition: ruleutils.c:5266
get_update_query_def
static void get_update_query_def(Query *query, deparse_context *context)
Definition: ruleutils.c:7156
get_json_constructor_options
static void get_json_constructor_options(JsonConstructorExpr *ctor, StringInfo buf)
Definition: ruleutils.c:11771
get_basic_select_query
static void get_basic_select_query(Query *query, deparse_context *context)
Definition: ruleutils.c:6111
isSimpleNode
static bool isSimpleNode(Node *node, Node *parentNode, int prettyFlags)
Definition: ruleutils.c:8863
get_with_clause
static void get_with_clause(Query *query, deparse_context *context)
Definition: ruleutils.c:5770
PRETTYINDENT_VAR
#define PRETTYINDENT_VAR
Definition: ruleutils.c:83
destroy_colinfo_names_hash
static void destroy_colinfo_names_hash(deparse_columns *colinfo)
Definition: ruleutils.c:5052
generate_relation_name
static char * generate_relation_name(Oid relid, List *namespaces)
Definition: ruleutils.c:13186
get_windowfunc_expr
static void get_windowfunc_expr(WindowFunc *wfunc, deparse_context *context)
Definition: ruleutils.c:11053
get_variable
static char * get_variable(Var *var, int levelsup, bool istoplevel, deparse_context *context)
Definition: ruleutils.c:7611
pg_get_serial_sequence
Datum pg_get_serial_sequence(PG_FUNCTION_ARGS)
Definition: ruleutils.c:2832
generate_operator_name
static char * generate_operator_name(Oid operid, Oid arg1, Oid arg2)
Definition: ruleutils.c:13397
get_from_clause_item
static void get_from_clause_item(Node *jtnode, Query *query, deparse_context *context)
Definition: ruleutils.c:12397
pg_get_function_arguments
Datum pg_get_function_arguments(PG_FUNCTION_ARGS)
Definition: ruleutils.c:3182
get_json_table
static void get_json_table(TableFunc *tf, deparse_context *context, bool showimplicit)
Definition: ruleutils.c:12215
PRETTYFLAG_SCHEMA
#define PRETTYFLAG_SCHEMA
Definition: ruleutils.c:90
get_select_query_def
static void get_select_query_def(Query *query, deparse_context *context)
Definition: ruleutils.c:5909
get_opclass_name
static void get_opclass_name(Oid opclass, Oid actual_datatype, StringInfo buf)
Definition: ruleutils.c:12894
pg_get_viewdef_name
Datum pg_get_viewdef_name(PG_FUNCTION_ARGS)
Definition: ruleutils.c:736
pg_get_userbyid
Datum pg_get_userbyid(PG_FUNCTION_ARGS)
Definition: ruleutils.c:2794
get_agg_expr_helper
static void get_agg_expr_helper(Aggref *aggref, deparse_context *context, Aggref *original_aggref, const char *funcname, const char *options, bool is_json_objectagg)
Definition: ruleutils.c:10911
RULE_INDEXDEF_PRETTY
#define RULE_INDEXDEF_PRETTY
Definition: ruleutils.h:24
RULE_INDEXDEF_KEYS_ONLY
#define RULE_INDEXDEF_KEYS_ONLY
Definition: ruleutils.h:25
standard_conforming_strings
bool standard_conforming_strings
Definition: scan.l:70
ScanKeyInit
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition: scankey.c:76
GetTransactionSnapshot
Snapshot GetTransactionSnapshot(void)
Definition: snapmgr.c:271
UnregisterSnapshot
void UnregisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:864
RegisterSnapshot
Snapshot RegisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:822
SPI_fnumber
int SPI_fnumber(TupleDesc tupdesc, const char *fname)
Definition: spi.c:1175
SPI_processed
uint64 SPI_processed
Definition: spi.c:44
SPI_tuptable
SPITupleTable * SPI_tuptable
Definition: spi.c:45
SPI_execute_plan
int SPI_execute_plan(SPIPlanPtr plan, const Datum *Values, const char *Nulls, bool read_only, long tcount)
Definition: spi.c:672
SPI_connect
int SPI_connect(void)
Definition: spi.c:94
SPI_finish
int SPI_finish(void)
Definition: spi.c:182
SPI_prepare
SPIPlanPtr SPI_prepare(const char *src, int nargs, Oid *argtypes)
Definition: spi.c:860
SPI_keepplan
int SPI_keepplan(SPIPlanPtr plan)
Definition: spi.c:976
SPI_getvalue
char * SPI_getvalue(HeapTuple tuple, TupleDesc tupdesc, int fnumber)
Definition: spi.c:1220
SPI_getbinval
Datum SPI_getbinval(HeapTuple tuple, TupleDesc tupdesc, int fnumber, bool *isnull)
Definition: spi.c:1252
SPI_OK_FINISH
#define SPI_OK_FINISH
Definition: spi.h:83
SPI_OK_SELECT
#define SPI_OK_SELECT
Definition: spi.h:86
relation_close
void relation_close(Relation relation, LOCKMODE lockmode)
Definition: relation.c:205
try_relation_open
Relation try_relation_open(Oid relationId, LOCKMODE lockmode)
Definition: relation.c:88
relation_open
Relation relation_open(Oid relationId, LOCKMODE lockmode)
Definition: relation.c:47
check_stack_depth
void check_stack_depth(void)
Definition: stack_depth.c:95
BTEqualStrategyNumber
#define BTEqualStrategyNumber
Definition: stratnum.h:31
resetStringInfo
void resetStringInfo(StringInfo str)
Definition: stringinfo.c:126
appendStringInfo
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:145
appendBinaryStringInfo
void appendBinaryStringInfo(StringInfo str, const void *data, int datalen)
Definition: stringinfo.c:281
appendStringInfoSpaces
void appendStringInfoSpaces(StringInfo str, int count)
Definition: stringinfo.c:260
appendStringInfoString
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:230
appendStringInfoChar
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:242
initStringInfo
void initStringInfo(StringInfo str)
Definition: stringinfo.c:97
Aggref::aggfnoid
Oid aggfnoid
Definition: primnodes.h:463
Aggref::aggdistinct
List * aggdistinct
Definition: primnodes.h:493
Aggref::aggdirectargs
List * aggdirectargs
Definition: primnodes.h:484
Aggref::args
List * args
Definition: primnodes.h:487
Aggref::aggfilter
Expr * aggfilter
Definition: primnodes.h:496
Aggref::aggorder
List * aggorder
Definition: primnodes.h:490
AppendRelInfo::child_relid
Index child_relid
Definition: pathnodes.h:3192
AppendRelInfo::parent_relid
Index parent_relid
Definition: pathnodes.h:3191
AppendRelInfo::num_child_cols
int num_child_cols
Definition: pathnodes.h:3227
BoolExpr::boolop
BoolExprType boolop
Definition: primnodes.h:971
BoolExpr::args
List * args
Definition: primnodes.h:972
BooleanTest::booltesttype
BoolTestType booltesttype
Definition: primnodes.h:2008
BooleanTest::arg
Expr * arg
Definition: primnodes.h:2007
CaseExpr::arg
Expr * arg
Definition: primnodes.h:1346
CaseExpr::defresult
Expr * defresult
Definition: primnodes.h:1348
CaseExpr::args
List * args
Definition: primnodes.h:1347
CoalesceExpr::args
List * args
Definition: primnodes.h:1517
CoerceViaIO::arg
Expr * arg
Definition: primnodes.h:1240
CoerceViaIO::resulttype
Oid resulttype
Definition: primnodes.h:1241
CollateExpr::arg
Expr * arg
Definition: primnodes.h:1312
CommonTableExpr::ctematerialized
CTEMaterialize ctematerialized
Definition: parsenodes.h:1710
CompactAttribute::attisdropped
bool attisdropped
Definition: tupdesc.h:77
Const::consttype
Oid consttype
Definition: primnodes.h:329
CurrentOfExpr::cursor_name
char * cursor_name
Definition: primnodes.h:2123
FieldSelect::fieldnum
AttrNumber fieldnum
Definition: primnodes.h:1162
FieldSelect::arg
Expr * arg
Definition: primnodes.h:1161
FieldStore::newvals
List * newvals
Definition: primnodes.h:1193
FromExpr::quals
Node * quals
Definition: primnodes.h:2358
FromExpr::fromlist
List * fromlist
Definition: primnodes.h:2357
FuncExpr::funcid
Oid funcid
Definition: primnodes.h:782
FuncExpr::args
List * args
Definition: primnodes.h:800
GroupingSet::content
List * content
Definition: parsenodes.h:1541
HASHCTL::keysize
Size keysize
Definition: hsearch.h:75
HASHCTL::entrysize
Size entrysize
Definition: hsearch.h:76
HASHCTL::hcxt
MemoryContext hcxt
Definition: hsearch.h:86
HTAB
Definition: dynahash.c:222
IndexAmRoutine::amcanorder
bool amcanorder
Definition: amapi.h:246
JsonBehavior::expr
Node * expr
Definition: primnodes.h:1816
JsonBehavior::btype
JsonBehaviorType btype
Definition: primnodes.h:1815
JsonConstructorExpr::returning
JsonReturning * returning
Definition: primnodes.h:1735
JsonConstructorExpr::type
JsonConstructorType type
Definition: primnodes.h:1731
JsonExpr::formatted_expr
Node * formatted_expr
Definition: primnodes.h:1848
JsonExpr::passing_values
List * passing_values
Definition: primnodes.h:1861
JsonExpr::on_empty
JsonBehavior * on_empty
Definition: primnodes.h:1864
JsonExpr::format
JsonFormat * format
Definition: primnodes.h:1851
JsonExpr::passing_names
List * passing_names
Definition: primnodes.h:1860
JsonExpr::path_spec
Node * path_spec
Definition: primnodes.h:1854
JsonExpr::returning
JsonReturning * returning
Definition: primnodes.h:1857
JsonExpr::wrapper
JsonWrapper wrapper
Definition: primnodes.h:1875
JsonExpr::op
JsonExprOp op
Definition: primnodes.h:1842
JsonExpr::on_error
JsonBehavior * on_error
Definition: primnodes.h:1865
JsonExpr::omit_quotes
bool omit_quotes
Definition: primnodes.h:1878
JsonFormat::format_type
JsonFormatType format_type
Definition: primnodes.h:1676
JsonIsPredicate::item_type
JsonValueType item_type
Definition: primnodes.h:1762
JsonReturning::format
JsonFormat * format
Definition: primnodes.h:1688
JsonTablePathScan::path
JsonTablePath * path
Definition: primnodes.h:1923
JsonTablePathScan::child
JsonTablePlan * child
Definition: primnodes.h:1932
JsonTablePath::value
Const * value
Definition: primnodes.h:1896
JsonTableSiblingJoin::rplan
JsonTablePlan * rplan
Definition: primnodes.h:1953
JsonTableSiblingJoin::lplan
JsonTablePlan * lplan
Definition: primnodes.h:1952
JsonValueExpr::format
JsonFormat * format
Definition: primnodes.h:1710
JsonValueExpr::raw_expr
Expr * raw_expr
Definition: primnodes.h:1708
List
Definition: pg_list.h:54
MinMaxExpr::args
List * args
Definition: primnodes.h:1543
MinMaxExpr::op
MinMaxOp op
Definition: primnodes.h:1541
NamedArgExpr::arg
Expr * arg
Definition: primnodes.h:823
NestLoopParam::paramval
Var * paramval
Definition: plannodes.h:1000
NestLoop::nestParams
List * nestParams
Definition: plannodes.h:989
Node
Definition: nodes.h:135
NullTest::nulltesttype
NullTestType nulltesttype
Definition: primnodes.h:1984
NullTest::arg
Expr * arg
Definition: primnodes.h:1983
OnConflictExpr::arbiterElems
List * arbiterElems
Definition: primnodes.h:2376
OnConflictExpr::action
OnConflictAction action
Definition: primnodes.h:2373
OnConflictExpr::onConflictSet
List * onConflictSet
Definition: primnodes.h:2382
OnConflictExpr::onConflictWhere
Node * onConflictWhere
Definition: primnodes.h:2383
OnConflictExpr::arbiterWhere
Node * arbiterWhere
Definition: primnodes.h:2378
OpExpr::opno
Oid opno
Definition: primnodes.h:850
OpExpr::args
List * args
Definition: primnodes.h:868
Param::paramid
int paramid
Definition: primnodes.h:396
Param::paramkind
ParamKind paramkind
Definition: primnodes.h:395
PartitionRangeDatum::kind
PartitionRangeDatumKind kind
Definition: parsenodes.h:961
Plan::targetlist
List * targetlist
Definition: plannodes.h:229
PlannedStmt::appendRelations
List * appendRelations
Definition: plannodes.h:127
PlannedStmt::subplans
List * subplans
Definition: plannodes.h:132
PlannedStmt::rtable
List * rtable
Definition: plannodes.h:109
Query::rowMarks
List * rowMarks
Definition: parsenodes.h:234
Query::groupDistinct
bool groupDistinct
Definition: parsenodes.h:217
Query::mergeJoinCondition
Node * mergeJoinCondition
Definition: parsenodes.h:196
Query::limitCount
Node * limitCount
Definition: parsenodes.h:231
Query::jointree
FromExpr * jointree
Definition: parsenodes.h:182
Query::returningList
List * returningList
Definition: parsenodes.h:214
Query::setOperations
Node * setOperations
Definition: parsenodes.h:236
Query::cteList
List * cteList
Definition: parsenodes.h:173
Query::onConflict
OnConflictExpr * onConflict
Definition: parsenodes.h:203
Query::groupClause
List * groupClause
Definition: parsenodes.h:216
Query::havingQual
Node * havingQual
Definition: parsenodes.h:222
Query::rtable
List * rtable
Definition: parsenodes.h:175
Query::limitOffset
Node * limitOffset
Definition: parsenodes.h:230
Query::commandType
CmdType commandType
Definition: parsenodes.h:121
Query::limitOption
LimitOption limitOption
Definition: parsenodes.h:232
Query::utilityStmt
Node * utilityStmt
Definition: parsenodes.h:141
Query::mergeActionList
List * mergeActionList
Definition: parsenodes.h:185
Query::windowClause
List * windowClause
Definition: parsenodes.h:224
Query::targetList
List * targetList
Definition: parsenodes.h:198
Query::groupingSets
List * groupingSets
Definition: parsenodes.h:220
Query::groupByAll
bool groupByAll
Definition: parsenodes.h:218
Query::distinctClause
List * distinctClause
Definition: parsenodes.h:226
Query::sortClause
List * sortClause
Definition: parsenodes.h:228
RangeTblEntry::ctename
char * ctename
Definition: parsenodes.h:1227
RangeTblEntry::tablefunc
TableFunc * tablefunc
Definition: parsenodes.h:1215
RangeTblEntry::ctelevelsup
Index ctelevelsup
Definition: parsenodes.h:1229
RangeTblEntry::funcordinality
bool funcordinality
Definition: parsenodes.h:1210
RangeTblEntry::tablesample
struct TableSampleClause * tablesample
Definition: parsenodes.h:1129
RangeTblEntry::subquery
Query * subquery
Definition: parsenodes.h:1135
RangeTblEntry::values_lists
List * values_lists
Definition: parsenodes.h:1221
RangeTblEntry::functions
List * functions
Definition: parsenodes.h:1208
RangeTblEntry::rtekind
RTEKind rtekind
Definition: parsenodes.h:1078
RangeVar::relname
char * relname
Definition: primnodes.h:83
RelabelType::resulttype
Oid resulttype
Definition: primnodes.h:1218
RelabelType::arg
Expr * arg
Definition: primnodes.h:1217
RelationData::rd_att
TupleDesc rd_att
Definition: rel.h:112
ReturningExpr::retexpr
Expr * retexpr
Definition: primnodes.h:2177
RowExpr::args
List * args
Definition: primnodes.h:1448
RowMarkClause::strength
LockClauseStrength strength
Definition: parsenodes.h:1611
RowMarkClause::waitPolicy
LockWaitPolicy waitPolicy
Definition: parsenodes.h:1612
SPITupleTable::tupdesc
TupleDesc tupdesc
Definition: spi.h:25
SPITupleTable::vals
HeapTuple * vals
Definition: spi.h:26
SQLValueFunction::op
SQLValueFunctionOp op
Definition: primnodes.h:1581
SetOperationStmt::op
SetOperation op
Definition: parsenodes.h:2255
SortGroupClause::tleSortGroupRef
Index tleSortGroupRef
Definition: parsenodes.h:1469
String
Definition: value.h:64
SubPlan::plan_name
char * plan_name
Definition: primnodes.h:1104
SubPlan::args
List * args
Definition: primnodes.h:1124
SubPlan::paramIds
List * paramIds
Definition: primnodes.h:1100
SubPlan::isInitPlan
bool isInitPlan
Definition: primnodes.h:1111
SubPlan::useHashTable
bool useHashTable
Definition: primnodes.h:1112
SubPlan::testexpr
Node * testexpr
Definition: primnodes.h:1099
SubPlan::parParam
List * parParam
Definition: primnodes.h:1123
SubPlan::setParam
List * setParam
Definition: primnodes.h:1121
SubPlan::subLinkType
SubLinkType subLinkType
Definition: primnodes.h:1097
SubscriptingRef::refassgnexpr
Expr * refassgnexpr
Definition: primnodes.h:735
SubscriptingRef::refupperindexpr
List * refupperindexpr
Definition: primnodes.h:725
SubscriptingRef::refexpr
Expr * refexpr
Definition: primnodes.h:733
SubscriptingRef::reflowerindexpr
List * reflowerindexpr
Definition: primnodes.h:731
TableFunc::docexpr
Node * docexpr
Definition: primnodes.h:120
TableFunc::rowexpr
Node * rowexpr
Definition: primnodes.h:122
TableFunc::colexprs
List * colexprs
Definition: primnodes.h:132
TableFunc::functype
TableFuncType functype
Definition: primnodes.h:114
TargetEntry::expr
Expr * expr
Definition: primnodes.h:2239
TargetEntry::resno
AttrNumber resno
Definition: primnodes.h:2241
Var
Definition: primnodes.h:262
Var::varattno
AttrNumber varattno
Definition: primnodes.h:274
Var::varno
int varno
Definition: primnodes.h:269
Var::varreturningtype
VarReturningType varreturningtype
Definition: primnodes.h:297
Var::varlevelsup
Index varlevelsup
Definition: primnodes.h:294
WindowAgg::winname
char * winname
Definition: plannodes.h:1235
WindowAgg::winref
Index winref
Definition: plannodes.h:1238
WindowClause::startOffset
Node * startOffset
Definition: parsenodes.h:1578
WindowClause::partitionClause
List * partitionClause
Definition: parsenodes.h:1574
WindowClause::endOffset
Node * endOffset
Definition: parsenodes.h:1579
WindowClause::orderClause
List * orderClause
Definition: parsenodes.h:1576
WindowFunc::args
List * args
Definition: primnodes.h:605
WindowFunc::winref
Index winref
Definition: primnodes.h:611
WindowFunc::aggfilter
Expr * aggfilter
Definition: primnodes.h:607
WindowFunc::ignore_nulls
int ignore_nulls
Definition: primnodes.h:617
WindowFunc::winfnoid
Oid winfnoid
Definition: primnodes.h:597
XmlExpr::args
List * args
Definition: primnodes.h:1633
XmlExpr::indent
bool indent
Definition: primnodes.h:1637
XmlExpr::named_args
List * named_args
Definition: primnodes.h:1629
XmlExpr::op
XmlExprOp op
Definition: primnodes.h:1625
_SPI_plan
Definition: spi_priv.h:91
deparse_columns
Definition: ruleutils.c:235
deparse_columns::leftrti
int leftrti
Definition: ruleutils.c:295
deparse_columns::parentUsing
List * parentUsing
Definition: ruleutils.c:276
deparse_columns::printaliases
bool printaliases
Definition: ruleutils.c:273
deparse_columns::rightrti
int rightrti
Definition: ruleutils.c:296
deparse_columns::names_hash
HTAB * names_hash
Definition: ruleutils.c:308
deparse_columns::new_colnames
char ** new_colnames
Definition: ruleutils.c:269
deparse_columns::num_new_cols
int num_new_cols
Definition: ruleutils.c:268
deparse_columns::colnames
char ** colnames
Definition: ruleutils.c:252
deparse_columns::num_cols
int num_cols
Definition: ruleutils.c:251
deparse_columns::rightattnos
int * rightattnos
Definition: ruleutils.c:298
deparse_columns::usingNames
List * usingNames
Definition: ruleutils.c:299
deparse_columns::is_new_col
bool * is_new_col
Definition: ruleutils.c:270
deparse_columns::leftattnos
int * leftattnos
Definition: ruleutils.c:297
deparse_context
Definition: ruleutils.c:113
deparse_context::indentLevel
int indentLevel
Definition: ruleutils.c:121
deparse_context::resultDesc
TupleDesc resultDesc
Definition: ruleutils.c:116
deparse_context::buf
StringInfo buf
Definition: ruleutils.c:114
deparse_context::wrapColumn
int wrapColumn
Definition: ruleutils.c:120
deparse_context::targetList
List * targetList
Definition: ruleutils.c:117
deparse_context::inGroupBy
bool inGroupBy
Definition: ruleutils.c:124
deparse_context::colNamesVisible
bool colNamesVisible
Definition: ruleutils.c:123
deparse_context::namespaces
List * namespaces
Definition: ruleutils.c:115
deparse_context::varprefix
bool varprefix
Definition: ruleutils.c:122
deparse_context::varInOrderBy
bool varInOrderBy
Definition: ruleutils.c:125
deparse_context::windowClause
List * windowClause
Definition: ruleutils.c:118
deparse_context::appendparents
Bitmapset * appendparents
Definition: ruleutils.c:126
deparse_context::prettyFlags
int prettyFlags
Definition: ruleutils.c:119
deparse_namespace
Definition: ruleutils.c:163
deparse_namespace::rtable_names
List * rtable_names
Definition: ruleutils.c:165
deparse_namespace::inner_tlist
List * inner_tlist
Definition: ruleutils.c:181
deparse_namespace::unique_using
bool unique_using
Definition: ruleutils.c:173
deparse_namespace::rtable
List * rtable
Definition: ruleutils.c:164
deparse_namespace::outer_tlist
List * outer_tlist
Definition: ruleutils.c:180
deparse_namespace::inner_plan
Plan * inner_plan
Definition: ruleutils.c:179
deparse_namespace::funcname
char * funcname
Definition: ruleutils.c:184
deparse_namespace::ctes
List * ctes
Definition: ruleutils.c:168
deparse_namespace::argnames
char ** argnames
Definition: ruleutils.c:186
deparse_namespace::plan
Plan * plan
Definition: ruleutils.c:176
deparse_namespace::subplans
List * subplans
Definition: ruleutils.c:167
deparse_namespace::appendrels
AppendRelInfo ** appendrels
Definition: ruleutils.c:169
deparse_namespace::ret_old_alias
char * ret_old_alias
Definition: ruleutils.c:170
deparse_namespace::rtable_columns
List * rtable_columns
Definition: ruleutils.c:166
deparse_namespace::ret_new_alias
char * ret_new_alias
Definition: ruleutils.c:171
deparse_namespace::index_tlist
List * index_tlist
Definition: ruleutils.c:182
deparse_namespace::ancestors
List * ancestors
Definition: ruleutils.c:177
deparse_namespace::numargs
int numargs
Definition: ruleutils.c:185
deparse_namespace::outer_plan
Plan * outer_plan
Definition: ruleutils.c:178
deparse_namespace::using_names
List * using_names
Definition: ruleutils.c:174
int2vector
Definition: c.h:725
int2vector::values
int16 values[FLEXIBLE_ARRAY_MEMBER]
Definition: c.h:732
nameData
Definition: c.h:751
oidvector
Definition: c.h:736
oidvector::values
Oid values[FLEXIBLE_ARRAY_MEMBER]
Definition: c.h:743
varlena
Definition: c.h:697
when
Definition: type.h:89
ReleaseSysCache
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:264
SearchSysCache1
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:220
SysCacheGetAttr
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition: syscache.c:595
SysCacheGetAttrNotNull
Datum SysCacheGetAttrNotNull(int cacheId, HeapTuple tup, AttrNumber attributeNumber)
Definition: syscache.c:625
table_close
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
table_open
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40
callback
static void callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)
Definition: test_ifaddrs.c:46
get_sortgroupref_tle
TargetEntry * get_sortgroupref_tle(Index sortref, List *targetList)
Definition: tlist.c:345
count_nonjunk_tlist_entries
int count_nonjunk_tlist_entries(List *tlist)
Definition: tlist.c:186
ReleaseTupleDesc
#define ReleaseTupleDesc(tupdesc)
Definition: tupdesc.h:219
TupleDescAttr
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:160
TupleDescCompactAttr
static CompactAttribute * TupleDescCompactAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:175
lookup_rowtype_tupdesc
TupleDesc lookup_rowtype_tupdesc(Oid type_id, int32 typmod)
Definition: typcache.c:1921
lookup_type_cache
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
Definition: typcache.c:386
TYPECACHE_GT_OPR
#define TYPECACHE_GT_OPR
Definition: typcache.h:140
TYPECACHE_LT_OPR
#define TYPECACHE_LT_OPR
Definition: typcache.h:139
makeString
String * makeString(char *str)
Definition: value.c:63
strVal
#define strVal(v)
Definition: value.h:82
flatten_group_exprs
Node * flatten_group_exprs(PlannerInfo *root, Query *query, Node *node)
Definition: var.c:968
pull_varnos
Relids pull_varnos(PlannerInfo *root, Node *node)
Definition: var.c:114
VARDATA_ANY
static char * VARDATA_ANY(const void *PTR)
Definition: varatt.h:486
cstring_to_text_with_len
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:193
SplitGUCList
bool SplitGUCList(char *rawstring, char separator, List **namelist)
Definition: varlena.c:2992
cstring_to_text
text * cstring_to_text(const char *s)
Definition: varlena.c:181
text_to_cstring
char * text_to_cstring(const text *t)
Definition: varlena.c:214
textToQualifiedNameList
List * textToQualifiedNameList(text *textval)
Definition: varlena.c:2686
type
const char * type
Definition: wait_event_funcs.c:27
name
const char * name
Definition: wait_event_funcs.c:28
map_xml_name_to_sql_identifier
char * map_xml_name_to_sql_identifier(const char *name)
Definition: xml.c:2474
XML_STANDALONE_NO_VALUE
@ XML_STANDALONE_NO_VALUE
Definition: xml.h:29
XML_STANDALONE_YES
@ XML_STANDALONE_YES
Definition: xml.h:27
XML_STANDALONE_NO
@ XML_STANDALONE_NO
Definition: xml.h:28
convert
static void convert(const int32 val, char *const buf)
Definition: zic.c:1992