LCOV - code coverage report
Current view: top level - src/backend/utils/adt - ruleutils.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 4626 5117 90.4 %
Date: 2024-09-08 21:11:44 Functions: 163 164 99.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * ruleutils.c
       4             :  *    Functions to convert stored expressions/querytrees back to
       5             :  *    source text
       6             :  *
       7             :  * Portions Copyright (c) 1996-2024, 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 */
     112             : typedef 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             :  */
     162             : typedef 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             :     /* Workspace for column alias assignment: */
     171             :     bool        unique_using;   /* Are we making USING names globally unique */
     172             :     List       *using_names;    /* List of assigned names for USING columns */
     173             :     /* Remaining fields are used only when deparsing a Plan tree: */
     174             :     Plan       *plan;           /* immediate parent of current expression */
     175             :     List       *ancestors;      /* ancestors of plan */
     176             :     Plan       *outer_plan;     /* outer subnode, or NULL if none */
     177             :     Plan       *inner_plan;     /* inner subnode, or NULL if none */
     178             :     List       *outer_tlist;    /* referent for OUTER_VAR Vars */
     179             :     List       *inner_tlist;    /* referent for INNER_VAR Vars */
     180             :     List       *index_tlist;    /* referent for INDEX_VAR Vars */
     181             :     /* Special namespace representing a function signature: */
     182             :     char       *funcname;
     183             :     int         numargs;
     184             :     char      **argnames;
     185             : } deparse_namespace;
     186             : 
     187             : /*
     188             :  * Per-relation data about column alias names.
     189             :  *
     190             :  * Selecting aliases is unreasonably complicated because of the need to dump
     191             :  * rules/views whose underlying tables may have had columns added, deleted, or
     192             :  * renamed since the query was parsed.  We must nonetheless print the rule/view
     193             :  * in a form that can be reloaded and will produce the same results as before.
     194             :  *
     195             :  * For each RTE used in the query, we must assign column aliases that are
     196             :  * unique within that RTE.  SQL does not require this of the original query,
     197             :  * but due to factors such as *-expansion we need to be able to uniquely
     198             :  * reference every column in a decompiled query.  As long as we qualify all
     199             :  * column references, per-RTE uniqueness is sufficient for that.
     200             :  *
     201             :  * However, we can't ensure per-column name uniqueness for unnamed join RTEs,
     202             :  * since they just inherit column names from their input RTEs, and we can't
     203             :  * rename the columns at the join level.  Most of the time this isn't an issue
     204             :  * because we don't need to reference the join's output columns as such; we
     205             :  * can reference the input columns instead.  That approach can fail for merged
     206             :  * JOIN USING columns, however, so when we have one of those in an unnamed
     207             :  * join, we have to make that column's alias globally unique across the whole
     208             :  * query to ensure it can be referenced unambiguously.
     209             :  *
     210             :  * Another problem is that a JOIN USING clause requires the columns to be
     211             :  * merged to have the same aliases in both input RTEs, and that no other
     212             :  * columns in those RTEs or their children conflict with the USING names.
     213             :  * To handle that, we do USING-column alias assignment in a recursive
     214             :  * traversal of the query's jointree.  When descending through a JOIN with
     215             :  * USING, we preassign the USING column names to the child columns, overriding
     216             :  * other rules for column alias assignment.  We also mark each RTE with a list
     217             :  * of all USING column names selected for joins containing that RTE, so that
     218             :  * when we assign other columns' aliases later, we can avoid conflicts.
     219             :  *
     220             :  * Another problem is that if a JOIN's input tables have had columns added or
     221             :  * deleted since the query was parsed, we must generate a column alias list
     222             :  * for the join that matches the current set of input columns --- otherwise, a
     223             :  * change in the number of columns in the left input would throw off matching
     224             :  * of aliases to columns of the right input.  Thus, positions in the printable
     225             :  * column alias list are not necessarily one-for-one with varattnos of the
     226             :  * JOIN, so we need a separate new_colnames[] array for printing purposes.
     227             :  */
     228             : typedef struct
     229             : {
     230             :     /*
     231             :      * colnames is an array containing column aliases to use for columns that
     232             :      * existed when the query was parsed.  Dropped columns have NULL entries.
     233             :      * This array can be directly indexed by varattno to get a Var's name.
     234             :      *
     235             :      * Non-NULL entries are guaranteed unique within the RTE, *except* when
     236             :      * this is for an unnamed JOIN RTE.  In that case we merely copy up names
     237             :      * from the two input RTEs.
     238             :      *
     239             :      * During the recursive descent in set_using_names(), forcible assignment
     240             :      * of a child RTE's column name is represented by pre-setting that element
     241             :      * of the child's colnames array.  So at that stage, NULL entries in this
     242             :      * array just mean that no name has been preassigned, not necessarily that
     243             :      * the column is dropped.
     244             :      */
     245             :     int         num_cols;       /* length of colnames[] array */
     246             :     char      **colnames;       /* array of C strings and NULLs */
     247             : 
     248             :     /*
     249             :      * new_colnames is an array containing column aliases to use for columns
     250             :      * that would exist if the query was re-parsed against the current
     251             :      * definitions of its base tables.  This is what to print as the column
     252             :      * alias list for the RTE.  This array does not include dropped columns,
     253             :      * but it will include columns added since original parsing.  Indexes in
     254             :      * it therefore have little to do with current varattno values.  As above,
     255             :      * entries are unique unless this is for an unnamed JOIN RTE.  (In such an
     256             :      * RTE, we never actually print this array, but we must compute it anyway
     257             :      * for possible use in computing column names of upper joins.) The
     258             :      * parallel array is_new_col marks which of these columns are new since
     259             :      * original parsing.  Entries with is_new_col false must match the
     260             :      * non-NULL colnames entries one-for-one.
     261             :      */
     262             :     int         num_new_cols;   /* length of new_colnames[] array */
     263             :     char      **new_colnames;   /* array of C strings */
     264             :     bool       *is_new_col;     /* array of bool flags */
     265             : 
     266             :     /* This flag tells whether we should actually print a column alias list */
     267             :     bool        printaliases;
     268             : 
     269             :     /* This list has all names used as USING names in joins above this RTE */
     270             :     List       *parentUsing;    /* names assigned to parent merged columns */
     271             : 
     272             :     /*
     273             :      * If this struct is for a JOIN RTE, we fill these fields during the
     274             :      * set_using_names() pass to describe its relationship to its child RTEs.
     275             :      *
     276             :      * leftattnos and rightattnos are arrays with one entry per existing
     277             :      * output column of the join (hence, indexable by join varattno).  For a
     278             :      * simple reference to a column of the left child, leftattnos[i] is the
     279             :      * child RTE's attno and rightattnos[i] is zero; and conversely for a
     280             :      * column of the right child.  But for merged columns produced by JOIN
     281             :      * USING/NATURAL JOIN, both leftattnos[i] and rightattnos[i] are nonzero.
     282             :      * Note that a simple reference might be to a child RTE column that's been
     283             :      * dropped; but that's OK since the column could not be used in the query.
     284             :      *
     285             :      * If it's a JOIN USING, usingNames holds the alias names selected for the
     286             :      * merged columns (these might be different from the original USING list,
     287             :      * if we had to modify names to achieve uniqueness).
     288             :      */
     289             :     int         leftrti;        /* rangetable index of left child */
     290             :     int         rightrti;       /* rangetable index of right child */
     291             :     int        *leftattnos;     /* left-child varattnos of join cols, or 0 */
     292             :     int        *rightattnos;    /* right-child varattnos of join cols, or 0 */
     293             :     List       *usingNames;     /* names assigned to merged columns */
     294             : } deparse_columns;
     295             : 
     296             : /* This macro is analogous to rt_fetch(), but for deparse_columns structs */
     297             : #define deparse_columns_fetch(rangetable_index, dpns) \
     298             :     ((deparse_columns *) list_nth((dpns)->rtable_columns, (rangetable_index)-1))
     299             : 
     300             : /*
     301             :  * Entry in set_rtable_names' hash table
     302             :  */
     303             : typedef struct
     304             : {
     305             :     char        name[NAMEDATALEN];  /* Hash key --- must be first */
     306             :     int         counter;        /* Largest addition used so far for name */
     307             : } NameHashEntry;
     308             : 
     309             : /* Callback signature for resolve_special_varno() */
     310             : typedef void (*rsv_callback) (Node *node, deparse_context *context,
     311             :                               void *callback_arg);
     312             : 
     313             : 
     314             : /* ----------
     315             :  * Global data
     316             :  * ----------
     317             :  */
     318             : static SPIPlanPtr plan_getrulebyoid = NULL;
     319             : static const char *const query_getrulebyoid = "SELECT * FROM pg_catalog.pg_rewrite WHERE oid = $1";
     320             : static SPIPlanPtr plan_getviewrule = NULL;
     321             : static const char *const query_getviewrule = "SELECT * FROM pg_catalog.pg_rewrite WHERE ev_class = $1 AND rulename = $2";
     322             : 
     323             : /* GUC parameters */
     324             : bool        quote_all_identifiers = false;
     325             : 
     326             : 
     327             : /* ----------
     328             :  * Local functions
     329             :  *
     330             :  * Most of these functions used to use fixed-size buffers to build their
     331             :  * results.  Now, they take an (already initialized) StringInfo object
     332             :  * as a parameter, and append their text output to its contents.
     333             :  * ----------
     334             :  */
     335             : static char *deparse_expression_pretty(Node *expr, List *dpcontext,
     336             :                                        bool forceprefix, bool showimplicit,
     337             :                                        int prettyFlags, int startIndent);
     338             : static char *pg_get_viewdef_worker(Oid viewoid,
     339             :                                    int prettyFlags, int wrapColumn);
     340             : static char *pg_get_triggerdef_worker(Oid trigid, bool pretty);
     341             : static int  decompile_column_index_array(Datum column_index_array, Oid relId,
     342             :                                          StringInfo buf);
     343             : static char *pg_get_ruledef_worker(Oid ruleoid, int prettyFlags);
     344             : static char *pg_get_indexdef_worker(Oid indexrelid, int colno,
     345             :                                     const Oid *excludeOps,
     346             :                                     bool attrsOnly, bool keysOnly,
     347             :                                     bool showTblSpc, bool inherits,
     348             :                                     int prettyFlags, bool missing_ok);
     349             : static char *pg_get_statisticsobj_worker(Oid statextid, bool columns_only,
     350             :                                          bool missing_ok);
     351             : static char *pg_get_partkeydef_worker(Oid relid, int prettyFlags,
     352             :                                       bool attrsOnly, bool missing_ok);
     353             : static char *pg_get_constraintdef_worker(Oid constraintId, bool fullCommand,
     354             :                                          int prettyFlags, bool missing_ok);
     355             : static text *pg_get_expr_worker(text *expr, Oid relid, int prettyFlags);
     356             : static int  print_function_arguments(StringInfo buf, HeapTuple proctup,
     357             :                                      bool print_table_args, bool print_defaults);
     358             : static void print_function_rettype(StringInfo buf, HeapTuple proctup);
     359             : static void print_function_trftypes(StringInfo buf, HeapTuple proctup);
     360             : static void print_function_sqlbody(StringInfo buf, HeapTuple proctup);
     361             : static void set_rtable_names(deparse_namespace *dpns, List *parent_namespaces,
     362             :                              Bitmapset *rels_used);
     363             : static void set_deparse_for_query(deparse_namespace *dpns, Query *query,
     364             :                                   List *parent_namespaces);
     365             : static void set_simple_column_names(deparse_namespace *dpns);
     366             : static bool has_dangerous_join_using(deparse_namespace *dpns, Node *jtnode);
     367             : static void set_using_names(deparse_namespace *dpns, Node *jtnode,
     368             :                             List *parentUsing);
     369             : static void set_relation_column_names(deparse_namespace *dpns,
     370             :                                       RangeTblEntry *rte,
     371             :                                       deparse_columns *colinfo);
     372             : static void set_join_column_names(deparse_namespace *dpns, RangeTblEntry *rte,
     373             :                                   deparse_columns *colinfo);
     374             : static bool colname_is_unique(const char *colname, deparse_namespace *dpns,
     375             :                               deparse_columns *colinfo);
     376             : static char *make_colname_unique(char *colname, deparse_namespace *dpns,
     377             :                                  deparse_columns *colinfo);
     378             : static void expand_colnames_array_to(deparse_columns *colinfo, int n);
     379             : static void identify_join_columns(JoinExpr *j, RangeTblEntry *jrte,
     380             :                                   deparse_columns *colinfo);
     381             : static char *get_rtable_name(int rtindex, deparse_context *context);
     382             : static void set_deparse_plan(deparse_namespace *dpns, Plan *plan);
     383             : static Plan *find_recursive_union(deparse_namespace *dpns,
     384             :                                   WorkTableScan *wtscan);
     385             : static void push_child_plan(deparse_namespace *dpns, Plan *plan,
     386             :                             deparse_namespace *save_dpns);
     387             : static void pop_child_plan(deparse_namespace *dpns,
     388             :                            deparse_namespace *save_dpns);
     389             : static void push_ancestor_plan(deparse_namespace *dpns, ListCell *ancestor_cell,
     390             :                                deparse_namespace *save_dpns);
     391             : static void pop_ancestor_plan(deparse_namespace *dpns,
     392             :                               deparse_namespace *save_dpns);
     393             : static void make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,
     394             :                          int prettyFlags);
     395             : static void make_viewdef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,
     396             :                          int prettyFlags, int wrapColumn);
     397             : static void get_query_def(Query *query, StringInfo buf, List *parentnamespace,
     398             :                           TupleDesc resultDesc, bool colNamesVisible,
     399             :                           int prettyFlags, int wrapColumn, int startIndent);
     400             : static void get_values_def(List *values_lists, deparse_context *context);
     401             : static void get_with_clause(Query *query, deparse_context *context);
     402             : static void get_select_query_def(Query *query, deparse_context *context);
     403             : static void get_insert_query_def(Query *query, deparse_context *context);
     404             : static void get_update_query_def(Query *query, deparse_context *context);
     405             : static void get_update_query_targetlist_def(Query *query, List *targetList,
     406             :                                             deparse_context *context,
     407             :                                             RangeTblEntry *rte);
     408             : static void get_delete_query_def(Query *query, deparse_context *context);
     409             : static void get_merge_query_def(Query *query, deparse_context *context);
     410             : static void get_utility_query_def(Query *query, deparse_context *context);
     411             : static void get_basic_select_query(Query *query, deparse_context *context);
     412             : static void get_target_list(List *targetList, deparse_context *context);
     413             : static void get_setop_query(Node *setOp, Query *query,
     414             :                             deparse_context *context);
     415             : static Node *get_rule_sortgroupclause(Index ref, List *tlist,
     416             :                                       bool force_colno,
     417             :                                       deparse_context *context);
     418             : static void get_rule_groupingset(GroupingSet *gset, List *targetlist,
     419             :                                  bool omit_parens, deparse_context *context);
     420             : static void get_rule_orderby(List *orderList, List *targetList,
     421             :                              bool force_colno, deparse_context *context);
     422             : static void get_rule_windowclause(Query *query, deparse_context *context);
     423             : static void get_rule_windowspec(WindowClause *wc, List *targetList,
     424             :                                 deparse_context *context);
     425             : static char *get_variable(Var *var, int levelsup, bool istoplevel,
     426             :                           deparse_context *context);
     427             : static void get_special_variable(Node *node, deparse_context *context,
     428             :                                  void *callback_arg);
     429             : static void resolve_special_varno(Node *node, deparse_context *context,
     430             :                                   rsv_callback callback, void *callback_arg);
     431             : static Node *find_param_referent(Param *param, deparse_context *context,
     432             :                                  deparse_namespace **dpns_p, ListCell **ancestor_cell_p);
     433             : static SubPlan *find_param_generator(Param *param, deparse_context *context,
     434             :                                      int *column_p);
     435             : static SubPlan *find_param_generator_initplan(Param *param, Plan *plan,
     436             :                                               int *column_p);
     437             : static void get_parameter(Param *param, deparse_context *context);
     438             : static const char *get_simple_binary_op_name(OpExpr *expr);
     439             : static bool isSimpleNode(Node *node, Node *parentNode, int prettyFlags);
     440             : static void appendContextKeyword(deparse_context *context, const char *str,
     441             :                                  int indentBefore, int indentAfter, int indentPlus);
     442             : static void removeStringInfoSpaces(StringInfo str);
     443             : static void get_rule_expr(Node *node, deparse_context *context,
     444             :                           bool showimplicit);
     445             : static void get_rule_expr_toplevel(Node *node, deparse_context *context,
     446             :                                    bool showimplicit);
     447             : static void get_rule_list_toplevel(List *lst, deparse_context *context,
     448             :                                    bool showimplicit);
     449             : static void get_rule_expr_funccall(Node *node, deparse_context *context,
     450             :                                    bool showimplicit);
     451             : static bool looks_like_function(Node *node);
     452             : static void get_oper_expr(OpExpr *expr, deparse_context *context);
     453             : static void get_func_expr(FuncExpr *expr, deparse_context *context,
     454             :                           bool showimplicit);
     455             : static void get_agg_expr(Aggref *aggref, deparse_context *context,
     456             :                          Aggref *original_aggref);
     457             : static void get_agg_expr_helper(Aggref *aggref, deparse_context *context,
     458             :                                 Aggref *original_aggref, const char *funcname,
     459             :                                 const char *options, bool is_json_objectagg);
     460             : static void get_agg_combine_expr(Node *node, deparse_context *context,
     461             :                                  void *callback_arg);
     462             : static void get_windowfunc_expr(WindowFunc *wfunc, deparse_context *context);
     463             : static void get_windowfunc_expr_helper(WindowFunc *wfunc, deparse_context *context,
     464             :                                        const char *funcname, const char *options,
     465             :                                        bool is_json_objectagg);
     466             : static bool get_func_sql_syntax(FuncExpr *expr, deparse_context *context);
     467             : static void get_coercion_expr(Node *arg, deparse_context *context,
     468             :                               Oid resulttype, int32 resulttypmod,
     469             :                               Node *parentNode);
     470             : static void get_const_expr(Const *constval, deparse_context *context,
     471             :                            int showtype);
     472             : static void get_const_collation(Const *constval, deparse_context *context);
     473             : static void get_json_format(JsonFormat *format, StringInfo buf);
     474             : static void get_json_returning(JsonReturning *returning, StringInfo buf,
     475             :                                bool json_format_by_default);
     476             : static void get_json_constructor(JsonConstructorExpr *ctor,
     477             :                                  deparse_context *context, bool showimplicit);
     478             : static void get_json_constructor_options(JsonConstructorExpr *ctor,
     479             :                                          StringInfo buf);
     480             : static void get_json_agg_constructor(JsonConstructorExpr *ctor,
     481             :                                      deparse_context *context,
     482             :                                      const char *funcname,
     483             :                                      bool is_json_objectagg);
     484             : static void simple_quote_literal(StringInfo buf, const char *val);
     485             : static void get_sublink_expr(SubLink *sublink, deparse_context *context);
     486             : static void get_tablefunc(TableFunc *tf, deparse_context *context,
     487             :                           bool showimplicit);
     488             : static void get_from_clause(Query *query, const char *prefix,
     489             :                             deparse_context *context);
     490             : static void get_from_clause_item(Node *jtnode, Query *query,
     491             :                                  deparse_context *context);
     492             : static void get_rte_alias(RangeTblEntry *rte, int varno, bool use_as,
     493             :                           deparse_context *context);
     494             : static void get_column_alias_list(deparse_columns *colinfo,
     495             :                                   deparse_context *context);
     496             : static void get_from_clause_coldeflist(RangeTblFunction *rtfunc,
     497             :                                        deparse_columns *colinfo,
     498             :                                        deparse_context *context);
     499             : static void get_tablesample_def(TableSampleClause *tablesample,
     500             :                                 deparse_context *context);
     501             : static void get_opclass_name(Oid opclass, Oid actual_datatype,
     502             :                              StringInfo buf);
     503             : static Node *processIndirection(Node *node, deparse_context *context);
     504             : static void printSubscripts(SubscriptingRef *sbsref, deparse_context *context);
     505             : static char *get_relation_name(Oid relid);
     506             : static char *generate_relation_name(Oid relid, List *namespaces);
     507             : static char *generate_qualified_relation_name(Oid relid);
     508             : static char *generate_function_name(Oid funcid, int nargs,
     509             :                                     List *argnames, Oid *argtypes,
     510             :                                     bool has_variadic, bool *use_variadic_p,
     511             :                                     bool inGroupBy);
     512             : static char *generate_operator_name(Oid operid, Oid arg1, Oid arg2);
     513             : static void add_cast_to(StringInfo buf, Oid typid);
     514             : static char *generate_qualified_type_name(Oid typid);
     515             : static text *string_to_text(char *str);
     516             : static char *flatten_reloptions(Oid relid);
     517             : static void get_reloptions(StringInfo buf, Datum reloptions);
     518             : static void get_json_path_spec(Node *path_spec, deparse_context *context,
     519             :                                bool showimplicit);
     520             : static void get_json_table_columns(TableFunc *tf, JsonTablePathScan *scan,
     521             :                                    deparse_context *context,
     522             :                                    bool showimplicit);
     523             : static void get_json_table_nested_columns(TableFunc *tf, JsonTablePlan *plan,
     524             :                                           deparse_context *context,
     525             :                                           bool showimplicit,
     526             :                                           bool needcomma);
     527             : 
     528             : #define only_marker(rte)  ((rte)->inh ? "" : "ONLY ")
     529             : 
     530             : 
     531             : /* ----------
     532             :  * pg_get_ruledef       - Do it all and return a text
     533             :  *                that could be used as a statement
     534             :  *                to recreate the rule
     535             :  * ----------
     536             :  */
     537             : Datum
     538         450 : pg_get_ruledef(PG_FUNCTION_ARGS)
     539             : {
     540         450 :     Oid         ruleoid = PG_GETARG_OID(0);
     541             :     int         prettyFlags;
     542             :     char       *res;
     543             : 
     544         450 :     prettyFlags = PRETTYFLAG_INDENT;
     545             : 
     546         450 :     res = pg_get_ruledef_worker(ruleoid, prettyFlags);
     547             : 
     548         450 :     if (res == NULL)
     549           6 :         PG_RETURN_NULL();
     550             : 
     551         444 :     PG_RETURN_TEXT_P(string_to_text(res));
     552             : }
     553             : 
     554             : 
     555             : Datum
     556         114 : pg_get_ruledef_ext(PG_FUNCTION_ARGS)
     557             : {
     558         114 :     Oid         ruleoid = PG_GETARG_OID(0);
     559         114 :     bool        pretty = PG_GETARG_BOOL(1);
     560             :     int         prettyFlags;
     561             :     char       *res;
     562             : 
     563         114 :     prettyFlags = GET_PRETTY_FLAGS(pretty);
     564             : 
     565         114 :     res = pg_get_ruledef_worker(ruleoid, prettyFlags);
     566             : 
     567         114 :     if (res == NULL)
     568           0 :         PG_RETURN_NULL();
     569             : 
     570         114 :     PG_RETURN_TEXT_P(string_to_text(res));
     571             : }
     572             : 
     573             : 
     574             : static char *
     575         564 : pg_get_ruledef_worker(Oid ruleoid, int prettyFlags)
     576             : {
     577             :     Datum       args[1];
     578             :     char        nulls[1];
     579             :     int         spirc;
     580             :     HeapTuple   ruletup;
     581             :     TupleDesc   rulettc;
     582             :     StringInfoData buf;
     583             : 
     584             :     /*
     585             :      * Do this first so that string is alloc'd in outer context not SPI's.
     586             :      */
     587         564 :     initStringInfo(&buf);
     588             : 
     589             :     /*
     590             :      * Connect to SPI manager
     591             :      */
     592         564 :     if (SPI_connect() != SPI_OK_CONNECT)
     593           0 :         elog(ERROR, "SPI_connect failed");
     594             : 
     595             :     /*
     596             :      * On the first call prepare the plan to lookup pg_rewrite. We read
     597             :      * pg_rewrite over the SPI manager instead of using the syscache to be
     598             :      * checked for read access on pg_rewrite.
     599             :      */
     600         564 :     if (plan_getrulebyoid == NULL)
     601             :     {
     602             :         Oid         argtypes[1];
     603             :         SPIPlanPtr  plan;
     604             : 
     605          40 :         argtypes[0] = OIDOID;
     606          40 :         plan = SPI_prepare(query_getrulebyoid, 1, argtypes);
     607          40 :         if (plan == NULL)
     608           0 :             elog(ERROR, "SPI_prepare failed for \"%s\"", query_getrulebyoid);
     609          40 :         SPI_keepplan(plan);
     610          40 :         plan_getrulebyoid = plan;
     611             :     }
     612             : 
     613             :     /*
     614             :      * Get the pg_rewrite tuple for this rule
     615             :      */
     616         564 :     args[0] = ObjectIdGetDatum(ruleoid);
     617         564 :     nulls[0] = ' ';
     618         564 :     spirc = SPI_execute_plan(plan_getrulebyoid, args, nulls, true, 0);
     619         564 :     if (spirc != SPI_OK_SELECT)
     620           0 :         elog(ERROR, "failed to get pg_rewrite tuple for rule %u", ruleoid);
     621         564 :     if (SPI_processed != 1)
     622             :     {
     623             :         /*
     624             :          * There is no tuple data available here, just keep the output buffer
     625             :          * empty.
     626             :          */
     627             :     }
     628             :     else
     629             :     {
     630             :         /*
     631             :          * Get the rule's definition and put it into executor's memory
     632             :          */
     633         558 :         ruletup = SPI_tuptable->vals[0];
     634         558 :         rulettc = SPI_tuptable->tupdesc;
     635         558 :         make_ruledef(&buf, ruletup, rulettc, prettyFlags);
     636             :     }
     637             : 
     638             :     /*
     639             :      * Disconnect from SPI manager
     640             :      */
     641         564 :     if (SPI_finish() != SPI_OK_FINISH)
     642           0 :         elog(ERROR, "SPI_finish failed");
     643             : 
     644         564 :     if (buf.len == 0)
     645           6 :         return NULL;
     646             : 
     647         558 :     return buf.data;
     648             : }
     649             : 
     650             : 
     651             : /* ----------
     652             :  * pg_get_viewdef       - Mainly the same thing, but we
     653             :  *                only return the SELECT part of a view
     654             :  * ----------
     655             :  */
     656             : Datum
     657        2378 : pg_get_viewdef(PG_FUNCTION_ARGS)
     658             : {
     659             :     /* By OID */
     660        2378 :     Oid         viewoid = PG_GETARG_OID(0);
     661             :     int         prettyFlags;
     662             :     char       *res;
     663             : 
     664        2378 :     prettyFlags = PRETTYFLAG_INDENT;
     665             : 
     666        2378 :     res = pg_get_viewdef_worker(viewoid, prettyFlags, WRAP_COLUMN_DEFAULT);
     667             : 
     668        2378 :     if (res == NULL)
     669           6 :         PG_RETURN_NULL();
     670             : 
     671        2372 :     PG_RETURN_TEXT_P(string_to_text(res));
     672             : }
     673             : 
     674             : 
     675             : Datum
     676         550 : pg_get_viewdef_ext(PG_FUNCTION_ARGS)
     677             : {
     678             :     /* By OID */
     679         550 :     Oid         viewoid = PG_GETARG_OID(0);
     680         550 :     bool        pretty = PG_GETARG_BOOL(1);
     681             :     int         prettyFlags;
     682             :     char       *res;
     683             : 
     684         550 :     prettyFlags = GET_PRETTY_FLAGS(pretty);
     685             : 
     686         550 :     res = pg_get_viewdef_worker(viewoid, prettyFlags, WRAP_COLUMN_DEFAULT);
     687             : 
     688         550 :     if (res == NULL)
     689           0 :         PG_RETURN_NULL();
     690             : 
     691         550 :     PG_RETURN_TEXT_P(string_to_text(res));
     692             : }
     693             : 
     694             : Datum
     695           6 : pg_get_viewdef_wrap(PG_FUNCTION_ARGS)
     696             : {
     697             :     /* By OID */
     698           6 :     Oid         viewoid = PG_GETARG_OID(0);
     699           6 :     int         wrap = PG_GETARG_INT32(1);
     700             :     int         prettyFlags;
     701             :     char       *res;
     702             : 
     703             :     /* calling this implies we want pretty printing */
     704           6 :     prettyFlags = GET_PRETTY_FLAGS(true);
     705             : 
     706           6 :     res = pg_get_viewdef_worker(viewoid, prettyFlags, wrap);
     707             : 
     708           6 :     if (res == NULL)
     709           0 :         PG_RETURN_NULL();
     710             : 
     711           6 :     PG_RETURN_TEXT_P(string_to_text(res));
     712             : }
     713             : 
     714             : Datum
     715          72 : pg_get_viewdef_name(PG_FUNCTION_ARGS)
     716             : {
     717             :     /* By qualified name */
     718          72 :     text       *viewname = PG_GETARG_TEXT_PP(0);
     719             :     int         prettyFlags;
     720             :     RangeVar   *viewrel;
     721             :     Oid         viewoid;
     722             :     char       *res;
     723             : 
     724          72 :     prettyFlags = PRETTYFLAG_INDENT;
     725             : 
     726             :     /* Look up view name.  Can't lock it - we might not have privileges. */
     727          72 :     viewrel = makeRangeVarFromNameList(textToQualifiedNameList(viewname));
     728          72 :     viewoid = RangeVarGetRelid(viewrel, NoLock, false);
     729             : 
     730          72 :     res = pg_get_viewdef_worker(viewoid, prettyFlags, WRAP_COLUMN_DEFAULT);
     731             : 
     732          72 :     if (res == NULL)
     733           0 :         PG_RETURN_NULL();
     734             : 
     735          72 :     PG_RETURN_TEXT_P(string_to_text(res));
     736             : }
     737             : 
     738             : 
     739             : Datum
     740         402 : pg_get_viewdef_name_ext(PG_FUNCTION_ARGS)
     741             : {
     742             :     /* By qualified name */
     743         402 :     text       *viewname = PG_GETARG_TEXT_PP(0);
     744         402 :     bool        pretty = PG_GETARG_BOOL(1);
     745             :     int         prettyFlags;
     746             :     RangeVar   *viewrel;
     747             :     Oid         viewoid;
     748             :     char       *res;
     749             : 
     750         402 :     prettyFlags = GET_PRETTY_FLAGS(pretty);
     751             : 
     752             :     /* Look up view name.  Can't lock it - we might not have privileges. */
     753         402 :     viewrel = makeRangeVarFromNameList(textToQualifiedNameList(viewname));
     754         402 :     viewoid = RangeVarGetRelid(viewrel, NoLock, false);
     755             : 
     756         402 :     res = pg_get_viewdef_worker(viewoid, prettyFlags, WRAP_COLUMN_DEFAULT);
     757             : 
     758         402 :     if (res == NULL)
     759           0 :         PG_RETURN_NULL();
     760             : 
     761         402 :     PG_RETURN_TEXT_P(string_to_text(res));
     762             : }
     763             : 
     764             : /*
     765             :  * Common code for by-OID and by-name variants of pg_get_viewdef
     766             :  */
     767             : static char *
     768        3408 : pg_get_viewdef_worker(Oid viewoid, int prettyFlags, int wrapColumn)
     769             : {
     770             :     Datum       args[2];
     771             :     char        nulls[2];
     772             :     int         spirc;
     773             :     HeapTuple   ruletup;
     774             :     TupleDesc   rulettc;
     775             :     StringInfoData buf;
     776             : 
     777             :     /*
     778             :      * Do this first so that string is alloc'd in outer context not SPI's.
     779             :      */
     780        3408 :     initStringInfo(&buf);
     781             : 
     782             :     /*
     783             :      * Connect to SPI manager
     784             :      */
     785        3408 :     if (SPI_connect() != SPI_OK_CONNECT)
     786           0 :         elog(ERROR, "SPI_connect failed");
     787             : 
     788             :     /*
     789             :      * On the first call prepare the plan to lookup pg_rewrite. We read
     790             :      * pg_rewrite over the SPI manager instead of using the syscache to be
     791             :      * checked for read access on pg_rewrite.
     792             :      */
     793        3408 :     if (plan_getviewrule == NULL)
     794             :     {
     795             :         Oid         argtypes[2];
     796             :         SPIPlanPtr  plan;
     797             : 
     798         234 :         argtypes[0] = OIDOID;
     799         234 :         argtypes[1] = NAMEOID;
     800         234 :         plan = SPI_prepare(query_getviewrule, 2, argtypes);
     801         234 :         if (plan == NULL)
     802           0 :             elog(ERROR, "SPI_prepare failed for \"%s\"", query_getviewrule);
     803         234 :         SPI_keepplan(plan);
     804         234 :         plan_getviewrule = plan;
     805             :     }
     806             : 
     807             :     /*
     808             :      * Get the pg_rewrite tuple for the view's SELECT rule
     809             :      */
     810        3408 :     args[0] = ObjectIdGetDatum(viewoid);
     811        3408 :     args[1] = DirectFunctionCall1(namein, CStringGetDatum(ViewSelectRuleName));
     812        3408 :     nulls[0] = ' ';
     813        3408 :     nulls[1] = ' ';
     814        3408 :     spirc = SPI_execute_plan(plan_getviewrule, args, nulls, true, 0);
     815        3408 :     if (spirc != SPI_OK_SELECT)
     816           0 :         elog(ERROR, "failed to get pg_rewrite tuple for view %u", viewoid);
     817        3408 :     if (SPI_processed != 1)
     818             :     {
     819             :         /*
     820             :          * There is no tuple data available here, just keep the output buffer
     821             :          * empty.
     822             :          */
     823             :     }
     824             :     else
     825             :     {
     826             :         /*
     827             :          * Get the rule's definition and put it into executor's memory
     828             :          */
     829        3402 :         ruletup = SPI_tuptable->vals[0];
     830        3402 :         rulettc = SPI_tuptable->tupdesc;
     831        3402 :         make_viewdef(&buf, ruletup, rulettc, prettyFlags, wrapColumn);
     832             :     }
     833             : 
     834             :     /*
     835             :      * Disconnect from SPI manager
     836             :      */
     837        3408 :     if (SPI_finish() != SPI_OK_FINISH)
     838           0 :         elog(ERROR, "SPI_finish failed");
     839             : 
     840        3408 :     if (buf.len == 0)
     841           6 :         return NULL;
     842             : 
     843        3402 :     return buf.data;
     844             : }
     845             : 
     846             : /* ----------
     847             :  * pg_get_triggerdef        - Get the definition of a trigger
     848             :  * ----------
     849             :  */
     850             : Datum
     851         204 : pg_get_triggerdef(PG_FUNCTION_ARGS)
     852             : {
     853         204 :     Oid         trigid = PG_GETARG_OID(0);
     854             :     char       *res;
     855             : 
     856         204 :     res = pg_get_triggerdef_worker(trigid, false);
     857             : 
     858         204 :     if (res == NULL)
     859           6 :         PG_RETURN_NULL();
     860             : 
     861         198 :     PG_RETURN_TEXT_P(string_to_text(res));
     862             : }
     863             : 
     864             : Datum
     865        1130 : pg_get_triggerdef_ext(PG_FUNCTION_ARGS)
     866             : {
     867        1130 :     Oid         trigid = PG_GETARG_OID(0);
     868        1130 :     bool        pretty = PG_GETARG_BOOL(1);
     869             :     char       *res;
     870             : 
     871        1130 :     res = pg_get_triggerdef_worker(trigid, pretty);
     872             : 
     873        1130 :     if (res == NULL)
     874           0 :         PG_RETURN_NULL();
     875             : 
     876        1130 :     PG_RETURN_TEXT_P(string_to_text(res));
     877             : }
     878             : 
     879             : static char *
     880        1334 : pg_get_triggerdef_worker(Oid trigid, bool pretty)
     881             : {
     882             :     HeapTuple   ht_trig;
     883             :     Form_pg_trigger trigrec;
     884             :     StringInfoData buf;
     885             :     Relation    tgrel;
     886             :     ScanKeyData skey[1];
     887             :     SysScanDesc tgscan;
     888        1334 :     int         findx = 0;
     889             :     char       *tgname;
     890             :     char       *tgoldtable;
     891             :     char       *tgnewtable;
     892             :     Datum       value;
     893             :     bool        isnull;
     894             : 
     895             :     /*
     896             :      * Fetch the pg_trigger tuple by the Oid of the trigger
     897             :      */
     898        1334 :     tgrel = table_open(TriggerRelationId, AccessShareLock);
     899             : 
     900        1334 :     ScanKeyInit(&skey[0],
     901             :                 Anum_pg_trigger_oid,
     902             :                 BTEqualStrategyNumber, F_OIDEQ,
     903             :                 ObjectIdGetDatum(trigid));
     904             : 
     905        1334 :     tgscan = systable_beginscan(tgrel, TriggerOidIndexId, true,
     906             :                                 NULL, 1, skey);
     907             : 
     908        1334 :     ht_trig = systable_getnext(tgscan);
     909             : 
     910        1334 :     if (!HeapTupleIsValid(ht_trig))
     911             :     {
     912           6 :         systable_endscan(tgscan);
     913           6 :         table_close(tgrel, AccessShareLock);
     914           6 :         return NULL;
     915             :     }
     916             : 
     917        1328 :     trigrec = (Form_pg_trigger) GETSTRUCT(ht_trig);
     918             : 
     919             :     /*
     920             :      * Start the trigger definition. Note that the trigger's name should never
     921             :      * be schema-qualified, but the trigger rel's name may be.
     922             :      */
     923        1328 :     initStringInfo(&buf);
     924             : 
     925        1328 :     tgname = NameStr(trigrec->tgname);
     926        2656 :     appendStringInfo(&buf, "CREATE %sTRIGGER %s ",
     927        1328 :                      OidIsValid(trigrec->tgconstraint) ? "CONSTRAINT " : "",
     928             :                      quote_identifier(tgname));
     929             : 
     930        1328 :     if (TRIGGER_FOR_BEFORE(trigrec->tgtype))
     931         520 :         appendStringInfoString(&buf, "BEFORE");
     932         808 :     else if (TRIGGER_FOR_AFTER(trigrec->tgtype))
     933         784 :         appendStringInfoString(&buf, "AFTER");
     934          24 :     else if (TRIGGER_FOR_INSTEAD(trigrec->tgtype))
     935          24 :         appendStringInfoString(&buf, "INSTEAD OF");
     936             :     else
     937           0 :         elog(ERROR, "unexpected tgtype value: %d", trigrec->tgtype);
     938             : 
     939        1328 :     if (TRIGGER_FOR_INSERT(trigrec->tgtype))
     940             :     {
     941         864 :         appendStringInfoString(&buf, " INSERT");
     942         864 :         findx++;
     943             :     }
     944        1328 :     if (TRIGGER_FOR_DELETE(trigrec->tgtype))
     945             :     {
     946         226 :         if (findx > 0)
     947          90 :             appendStringInfoString(&buf, " OR DELETE");
     948             :         else
     949         136 :             appendStringInfoString(&buf, " DELETE");
     950         226 :         findx++;
     951             :     }
     952        1328 :     if (TRIGGER_FOR_UPDATE(trigrec->tgtype))
     953             :     {
     954         648 :         if (findx > 0)
     955         320 :             appendStringInfoString(&buf, " OR UPDATE");
     956             :         else
     957         328 :             appendStringInfoString(&buf, " UPDATE");
     958         648 :         findx++;
     959             :         /* tgattr is first var-width field, so OK to access directly */
     960         648 :         if (trigrec->tgattr.dim1 > 0)
     961             :         {
     962             :             int         i;
     963             : 
     964          76 :             appendStringInfoString(&buf, " OF ");
     965         168 :             for (i = 0; i < trigrec->tgattr.dim1; i++)
     966             :             {
     967             :                 char       *attname;
     968             : 
     969          92 :                 if (i > 0)
     970          16 :                     appendStringInfoString(&buf, ", ");
     971          92 :                 attname = get_attname(trigrec->tgrelid,
     972          92 :                                       trigrec->tgattr.values[i], false);
     973          92 :                 appendStringInfoString(&buf, quote_identifier(attname));
     974             :             }
     975             :         }
     976             :     }
     977        1328 :     if (TRIGGER_FOR_TRUNCATE(trigrec->tgtype))
     978             :     {
     979           0 :         if (findx > 0)
     980           0 :             appendStringInfoString(&buf, " OR TRUNCATE");
     981             :         else
     982           0 :             appendStringInfoString(&buf, " TRUNCATE");
     983           0 :         findx++;
     984             :     }
     985             : 
     986             :     /*
     987             :      * In non-pretty mode, always schema-qualify the target table name for
     988             :      * safety.  In pretty mode, schema-qualify only if not visible.
     989             :      */
     990        2656 :     appendStringInfo(&buf, " ON %s ",
     991             :                      pretty ?
     992         138 :                      generate_relation_name(trigrec->tgrelid, NIL) :
     993        1190 :                      generate_qualified_relation_name(trigrec->tgrelid));
     994             : 
     995        1328 :     if (OidIsValid(trigrec->tgconstraint))
     996             :     {
     997           0 :         if (OidIsValid(trigrec->tgconstrrelid))
     998           0 :             appendStringInfo(&buf, "FROM %s ",
     999             :                              generate_relation_name(trigrec->tgconstrrelid, NIL));
    1000           0 :         if (!trigrec->tgdeferrable)
    1001           0 :             appendStringInfoString(&buf, "NOT ");
    1002           0 :         appendStringInfoString(&buf, "DEFERRABLE INITIALLY ");
    1003           0 :         if (trigrec->tginitdeferred)
    1004           0 :             appendStringInfoString(&buf, "DEFERRED ");
    1005             :         else
    1006           0 :             appendStringInfoString(&buf, "IMMEDIATE ");
    1007             :     }
    1008             : 
    1009        1328 :     value = fastgetattr(ht_trig, Anum_pg_trigger_tgoldtable,
    1010             :                         tgrel->rd_att, &isnull);
    1011        1328 :     if (!isnull)
    1012          98 :         tgoldtable = NameStr(*DatumGetName(value));
    1013             :     else
    1014        1230 :         tgoldtable = NULL;
    1015        1328 :     value = fastgetattr(ht_trig, Anum_pg_trigger_tgnewtable,
    1016             :                         tgrel->rd_att, &isnull);
    1017        1328 :     if (!isnull)
    1018         108 :         tgnewtable = NameStr(*DatumGetName(value));
    1019             :     else
    1020        1220 :         tgnewtable = NULL;
    1021        1328 :     if (tgoldtable != NULL || tgnewtable != NULL)
    1022             :     {
    1023         152 :         appendStringInfoString(&buf, "REFERENCING ");
    1024         152 :         if (tgoldtable != NULL)
    1025          98 :             appendStringInfo(&buf, "OLD TABLE AS %s ",
    1026             :                              quote_identifier(tgoldtable));
    1027         152 :         if (tgnewtable != NULL)
    1028         108 :             appendStringInfo(&buf, "NEW TABLE AS %s ",
    1029             :                              quote_identifier(tgnewtable));
    1030             :     }
    1031             : 
    1032        1328 :     if (TRIGGER_FOR_ROW(trigrec->tgtype))
    1033        1010 :         appendStringInfoString(&buf, "FOR EACH ROW ");
    1034             :     else
    1035         318 :         appendStringInfoString(&buf, "FOR EACH STATEMENT ");
    1036             : 
    1037             :     /* If the trigger has a WHEN qualification, add that */
    1038        1328 :     value = fastgetattr(ht_trig, Anum_pg_trigger_tgqual,
    1039             :                         tgrel->rd_att, &isnull);
    1040        1328 :     if (!isnull)
    1041             :     {
    1042             :         Node       *qual;
    1043             :         char        relkind;
    1044             :         deparse_context context;
    1045             :         deparse_namespace dpns;
    1046             :         RangeTblEntry *oldrte;
    1047             :         RangeTblEntry *newrte;
    1048             : 
    1049         138 :         appendStringInfoString(&buf, "WHEN (");
    1050             : 
    1051         138 :         qual = stringToNode(TextDatumGetCString(value));
    1052             : 
    1053         138 :         relkind = get_rel_relkind(trigrec->tgrelid);
    1054             : 
    1055             :         /* Build minimal OLD and NEW RTEs for the rel */
    1056         138 :         oldrte = makeNode(RangeTblEntry);
    1057         138 :         oldrte->rtekind = RTE_RELATION;
    1058         138 :         oldrte->relid = trigrec->tgrelid;
    1059         138 :         oldrte->relkind = relkind;
    1060         138 :         oldrte->rellockmode = AccessShareLock;
    1061         138 :         oldrte->alias = makeAlias("old", NIL);
    1062         138 :         oldrte->eref = oldrte->alias;
    1063         138 :         oldrte->lateral = false;
    1064         138 :         oldrte->inh = false;
    1065         138 :         oldrte->inFromCl = true;
    1066             : 
    1067         138 :         newrte = makeNode(RangeTblEntry);
    1068         138 :         newrte->rtekind = RTE_RELATION;
    1069         138 :         newrte->relid = trigrec->tgrelid;
    1070         138 :         newrte->relkind = relkind;
    1071         138 :         newrte->rellockmode = AccessShareLock;
    1072         138 :         newrte->alias = makeAlias("new", NIL);
    1073         138 :         newrte->eref = newrte->alias;
    1074         138 :         newrte->lateral = false;
    1075         138 :         newrte->inh = false;
    1076         138 :         newrte->inFromCl = true;
    1077             : 
    1078             :         /* Build two-element rtable */
    1079         138 :         memset(&dpns, 0, sizeof(dpns));
    1080         138 :         dpns.rtable = list_make2(oldrte, newrte);
    1081         138 :         dpns.subplans = NIL;
    1082         138 :         dpns.ctes = NIL;
    1083         138 :         dpns.appendrels = NULL;
    1084         138 :         set_rtable_names(&dpns, NIL, NULL);
    1085         138 :         set_simple_column_names(&dpns);
    1086             : 
    1087             :         /* Set up context with one-deep namespace stack */
    1088         138 :         context.buf = &buf;
    1089         138 :         context.namespaces = list_make1(&dpns);
    1090         138 :         context.resultDesc = NULL;
    1091         138 :         context.targetList = NIL;
    1092         138 :         context.windowClause = NIL;
    1093         138 :         context.varprefix = true;
    1094         138 :         context.prettyFlags = GET_PRETTY_FLAGS(pretty);
    1095         138 :         context.wrapColumn = WRAP_COLUMN_DEFAULT;
    1096         138 :         context.indentLevel = PRETTYINDENT_STD;
    1097         138 :         context.colNamesVisible = true;
    1098         138 :         context.inGroupBy = false;
    1099         138 :         context.varInOrderBy = false;
    1100         138 :         context.appendparents = NULL;
    1101             : 
    1102         138 :         get_rule_expr(qual, &context, false);
    1103             : 
    1104         138 :         appendStringInfoString(&buf, ") ");
    1105             :     }
    1106             : 
    1107        1328 :     appendStringInfo(&buf, "EXECUTE FUNCTION %s(",
    1108             :                      generate_function_name(trigrec->tgfoid, 0,
    1109             :                                             NIL, NULL,
    1110             :                                             false, NULL, false));
    1111             : 
    1112        1328 :     if (trigrec->tgnargs > 0)
    1113             :     {
    1114             :         char       *p;
    1115             :         int         i;
    1116             : 
    1117         450 :         value = fastgetattr(ht_trig, Anum_pg_trigger_tgargs,
    1118             :                             tgrel->rd_att, &isnull);
    1119         450 :         if (isnull)
    1120           0 :             elog(ERROR, "tgargs is null for trigger %u", trigid);
    1121         450 :         p = (char *) VARDATA_ANY(DatumGetByteaPP(value));
    1122        1196 :         for (i = 0; i < trigrec->tgnargs; i++)
    1123             :         {
    1124         746 :             if (i > 0)
    1125         296 :                 appendStringInfoString(&buf, ", ");
    1126         746 :             simple_quote_literal(&buf, p);
    1127             :             /* advance p to next string embedded in tgargs */
    1128        6756 :             while (*p)
    1129        6010 :                 p++;
    1130         746 :             p++;
    1131             :         }
    1132             :     }
    1133             : 
    1134             :     /* We deliberately do not put semi-colon at end */
    1135        1328 :     appendStringInfoChar(&buf, ')');
    1136             : 
    1137             :     /* Clean up */
    1138        1328 :     systable_endscan(tgscan);
    1139             : 
    1140        1328 :     table_close(tgrel, AccessShareLock);
    1141             : 
    1142        1328 :     return buf.data;
    1143             : }
    1144             : 
    1145             : /* ----------
    1146             :  * pg_get_indexdef          - Get the definition of an index
    1147             :  *
    1148             :  * In the extended version, there is a colno argument as well as pretty bool.
    1149             :  *  if colno == 0, we want a complete index definition.
    1150             :  *  if colno > 0, we only want the Nth index key's variable or expression.
    1151             :  *
    1152             :  * Note that the SQL-function versions of this omit any info about the
    1153             :  * index tablespace; this is intentional because pg_dump wants it that way.
    1154             :  * However pg_get_indexdef_string() includes the index tablespace.
    1155             :  * ----------
    1156             :  */
    1157             : Datum
    1158        4914 : pg_get_indexdef(PG_FUNCTION_ARGS)
    1159             : {
    1160        4914 :     Oid         indexrelid = PG_GETARG_OID(0);
    1161             :     int         prettyFlags;
    1162             :     char       *res;
    1163             : 
    1164        4914 :     prettyFlags = PRETTYFLAG_INDENT;
    1165             : 
    1166        4914 :     res = pg_get_indexdef_worker(indexrelid, 0, NULL,
    1167             :                                  false, false,
    1168             :                                  false, false,
    1169             :                                  prettyFlags, true);
    1170             : 
    1171        4914 :     if (res == NULL)
    1172           6 :         PG_RETURN_NULL();
    1173             : 
    1174        4908 :     PG_RETURN_TEXT_P(string_to_text(res));
    1175             : }
    1176             : 
    1177             : Datum
    1178        1706 : pg_get_indexdef_ext(PG_FUNCTION_ARGS)
    1179             : {
    1180        1706 :     Oid         indexrelid = PG_GETARG_OID(0);
    1181        1706 :     int32       colno = PG_GETARG_INT32(1);
    1182        1706 :     bool        pretty = PG_GETARG_BOOL(2);
    1183             :     int         prettyFlags;
    1184             :     char       *res;
    1185             : 
    1186        1706 :     prettyFlags = GET_PRETTY_FLAGS(pretty);
    1187             : 
    1188        1706 :     res = pg_get_indexdef_worker(indexrelid, colno, NULL,
    1189             :                                  colno != 0, false,
    1190             :                                  false, false,
    1191             :                                  prettyFlags, true);
    1192             : 
    1193        1706 :     if (res == NULL)
    1194           0 :         PG_RETURN_NULL();
    1195             : 
    1196        1706 :     PG_RETURN_TEXT_P(string_to_text(res));
    1197             : }
    1198             : 
    1199             : /*
    1200             :  * Internal version for use by ALTER TABLE.
    1201             :  * Includes a tablespace clause in the result.
    1202             :  * Returns a palloc'd C string; no pretty-printing.
    1203             :  */
    1204             : char *
    1205         212 : pg_get_indexdef_string(Oid indexrelid)
    1206             : {
    1207         212 :     return pg_get_indexdef_worker(indexrelid, 0, NULL,
    1208             :                                   false, false,
    1209             :                                   true, true,
    1210             :                                   0, false);
    1211             : }
    1212             : 
    1213             : /* Internal version that just reports the key-column definitions */
    1214             : char *
    1215         766 : pg_get_indexdef_columns(Oid indexrelid, bool pretty)
    1216             : {
    1217             :     int         prettyFlags;
    1218             : 
    1219         766 :     prettyFlags = GET_PRETTY_FLAGS(pretty);
    1220             : 
    1221         766 :     return pg_get_indexdef_worker(indexrelid, 0, NULL,
    1222             :                                   true, true,
    1223             :                                   false, false,
    1224             :                                   prettyFlags, false);
    1225             : }
    1226             : 
    1227             : /* Internal version, extensible with flags to control its behavior */
    1228             : char *
    1229           8 : pg_get_indexdef_columns_extended(Oid indexrelid, bits16 flags)
    1230             : {
    1231           8 :     bool        pretty = ((flags & RULE_INDEXDEF_PRETTY) != 0);
    1232           8 :     bool        keys_only = ((flags & RULE_INDEXDEF_KEYS_ONLY) != 0);
    1233             :     int         prettyFlags;
    1234             : 
    1235           8 :     prettyFlags = GET_PRETTY_FLAGS(pretty);
    1236             : 
    1237           8 :     return pg_get_indexdef_worker(indexrelid, 0, NULL,
    1238             :                                   true, keys_only,
    1239             :                                   false, false,
    1240             :                                   prettyFlags, false);
    1241             : }
    1242             : 
    1243             : /*
    1244             :  * Internal workhorse to decompile an index definition.
    1245             :  *
    1246             :  * This is now used for exclusion constraints as well: if excludeOps is not
    1247             :  * NULL then it points to an array of exclusion operator OIDs.
    1248             :  */
    1249             : static char *
    1250        7710 : pg_get_indexdef_worker(Oid indexrelid, int colno,
    1251             :                        const Oid *excludeOps,
    1252             :                        bool attrsOnly, bool keysOnly,
    1253             :                        bool showTblSpc, bool inherits,
    1254             :                        int prettyFlags, bool missing_ok)
    1255             : {
    1256             :     /* might want a separate isConstraint parameter later */
    1257        7710 :     bool        isConstraint = (excludeOps != NULL);
    1258             :     HeapTuple   ht_idx;
    1259             :     HeapTuple   ht_idxrel;
    1260             :     HeapTuple   ht_am;
    1261             :     Form_pg_index idxrec;
    1262             :     Form_pg_class idxrelrec;
    1263             :     Form_pg_am  amrec;
    1264             :     IndexAmRoutine *amroutine;
    1265             :     List       *indexprs;
    1266             :     ListCell   *indexpr_item;
    1267             :     List       *context;
    1268             :     Oid         indrelid;
    1269             :     int         keyno;
    1270             :     Datum       indcollDatum;
    1271             :     Datum       indclassDatum;
    1272             :     Datum       indoptionDatum;
    1273             :     oidvector  *indcollation;
    1274             :     oidvector  *indclass;
    1275             :     int2vector *indoption;
    1276             :     StringInfoData buf;
    1277             :     char       *str;
    1278             :     char       *sep;
    1279             : 
    1280             :     /*
    1281             :      * Fetch the pg_index tuple by the Oid of the index
    1282             :      */
    1283        7710 :     ht_idx = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexrelid));
    1284        7710 :     if (!HeapTupleIsValid(ht_idx))
    1285             :     {
    1286           6 :         if (missing_ok)
    1287           6 :             return NULL;
    1288           0 :         elog(ERROR, "cache lookup failed for index %u", indexrelid);
    1289             :     }
    1290        7704 :     idxrec = (Form_pg_index) GETSTRUCT(ht_idx);
    1291             : 
    1292        7704 :     indrelid = idxrec->indrelid;
    1293             :     Assert(indexrelid == idxrec->indexrelid);
    1294             : 
    1295             :     /* Must get indcollation, indclass, and indoption the hard way */
    1296        7704 :     indcollDatum = SysCacheGetAttrNotNull(INDEXRELID, ht_idx,
    1297             :                                           Anum_pg_index_indcollation);
    1298        7704 :     indcollation = (oidvector *) DatumGetPointer(indcollDatum);
    1299             : 
    1300        7704 :     indclassDatum = SysCacheGetAttrNotNull(INDEXRELID, ht_idx,
    1301             :                                            Anum_pg_index_indclass);
    1302        7704 :     indclass = (oidvector *) DatumGetPointer(indclassDatum);
    1303             : 
    1304        7704 :     indoptionDatum = SysCacheGetAttrNotNull(INDEXRELID, ht_idx,
    1305             :                                             Anum_pg_index_indoption);
    1306        7704 :     indoption = (int2vector *) DatumGetPointer(indoptionDatum);
    1307             : 
    1308             :     /*
    1309             :      * Fetch the pg_class tuple of the index relation
    1310             :      */
    1311        7704 :     ht_idxrel = SearchSysCache1(RELOID, ObjectIdGetDatum(indexrelid));
    1312        7704 :     if (!HeapTupleIsValid(ht_idxrel))
    1313           0 :         elog(ERROR, "cache lookup failed for relation %u", indexrelid);
    1314        7704 :     idxrelrec = (Form_pg_class) GETSTRUCT(ht_idxrel);
    1315             : 
    1316             :     /*
    1317             :      * Fetch the pg_am tuple of the index' access method
    1318             :      */
    1319        7704 :     ht_am = SearchSysCache1(AMOID, ObjectIdGetDatum(idxrelrec->relam));
    1320        7704 :     if (!HeapTupleIsValid(ht_am))
    1321           0 :         elog(ERROR, "cache lookup failed for access method %u",
    1322             :              idxrelrec->relam);
    1323        7704 :     amrec = (Form_pg_am) GETSTRUCT(ht_am);
    1324             : 
    1325             :     /* Fetch the index AM's API struct */
    1326        7704 :     amroutine = GetIndexAmRoutine(amrec->amhandler);
    1327             : 
    1328             :     /*
    1329             :      * Get the index expressions, if any.  (NOTE: we do not use the relcache
    1330             :      * versions of the expressions and predicate, because we want to display
    1331             :      * non-const-folded expressions.)
    1332             :      */
    1333        7704 :     if (!heap_attisnull(ht_idx, Anum_pg_index_indexprs, NULL))
    1334             :     {
    1335             :         Datum       exprsDatum;
    1336             :         char       *exprsString;
    1337             : 
    1338         546 :         exprsDatum = SysCacheGetAttrNotNull(INDEXRELID, ht_idx,
    1339             :                                             Anum_pg_index_indexprs);
    1340         546 :         exprsString = TextDatumGetCString(exprsDatum);
    1341         546 :         indexprs = (List *) stringToNode(exprsString);
    1342         546 :         pfree(exprsString);
    1343             :     }
    1344             :     else
    1345        7158 :         indexprs = NIL;
    1346             : 
    1347        7704 :     indexpr_item = list_head(indexprs);
    1348             : 
    1349        7704 :     context = deparse_context_for(get_relation_name(indrelid), indrelid);
    1350             : 
    1351             :     /*
    1352             :      * Start the index definition.  Note that the index's name should never be
    1353             :      * schema-qualified, but the indexed rel's name may be.
    1354             :      */
    1355        7704 :     initStringInfo(&buf);
    1356             : 
    1357        7704 :     if (!attrsOnly)
    1358             :     {
    1359        6480 :         if (!isConstraint)
    1360       12752 :             appendStringInfo(&buf, "CREATE %sINDEX %s ON %s%s USING %s (",
    1361        6376 :                              idxrec->indisunique ? "UNIQUE " : "",
    1362        6376 :                              quote_identifier(NameStr(idxrelrec->relname)),
    1363        6376 :                              idxrelrec->relkind == RELKIND_PARTITIONED_INDEX
    1364         634 :                              && !inherits ? "ONLY " : "",
    1365        6376 :                              (prettyFlags & PRETTYFLAG_SCHEMA) ?
    1366        1256 :                              generate_relation_name(indrelid, NIL) :
    1367        5120 :                              generate_qualified_relation_name(indrelid),
    1368        6376 :                              quote_identifier(NameStr(amrec->amname)));
    1369             :         else                    /* currently, must be EXCLUDE constraint */
    1370         104 :             appendStringInfo(&buf, "EXCLUDE USING %s (",
    1371         104 :                              quote_identifier(NameStr(amrec->amname)));
    1372             :     }
    1373             : 
    1374             :     /*
    1375             :      * Report the indexed attributes
    1376             :      */
    1377        7704 :     sep = "";
    1378       19228 :     for (keyno = 0; keyno < idxrec->indnatts; keyno++)
    1379             :     {
    1380       11622 :         AttrNumber  attnum = idxrec->indkey.values[keyno];
    1381             :         Oid         keycoltype;
    1382             :         Oid         keycolcollation;
    1383             : 
    1384             :         /*
    1385             :          * Ignore non-key attributes if told to.
    1386             :          */
    1387       11622 :         if (keysOnly && keyno >= idxrec->indnkeyatts)
    1388          98 :             break;
    1389             : 
    1390             :         /* Otherwise, print INCLUDE to divide key and non-key attrs. */
    1391       11524 :         if (!colno && keyno == idxrec->indnkeyatts)
    1392             :         {
    1393         250 :             appendStringInfoString(&buf, ") INCLUDE (");
    1394         250 :             sep = "";
    1395             :         }
    1396             : 
    1397       11524 :         if (!colno)
    1398       10894 :             appendStringInfoString(&buf, sep);
    1399       11524 :         sep = ", ";
    1400             : 
    1401       11524 :         if (attnum != 0)
    1402             :         {
    1403             :             /* Simple index column */
    1404             :             char       *attname;
    1405             :             int32       keycoltypmod;
    1406             : 
    1407       10832 :             attname = get_attname(indrelid, attnum, false);
    1408       10832 :             if (!colno || colno == keyno + 1)
    1409       10664 :                 appendStringInfoString(&buf, quote_identifier(attname));
    1410       10832 :             get_atttypetypmodcoll(indrelid, attnum,
    1411             :                                   &keycoltype, &keycoltypmod,
    1412             :                                   &keycolcollation);
    1413             :         }
    1414             :         else
    1415             :         {
    1416             :             /* expressional index */
    1417             :             Node       *indexkey;
    1418             : 
    1419         692 :             if (indexpr_item == NULL)
    1420           0 :                 elog(ERROR, "too few entries in indexprs list");
    1421         692 :             indexkey = (Node *) lfirst(indexpr_item);
    1422         692 :             indexpr_item = lnext(indexprs, indexpr_item);
    1423             :             /* Deparse */
    1424         692 :             str = deparse_expression_pretty(indexkey, context, false, false,
    1425             :                                             prettyFlags, 0);
    1426         692 :             if (!colno || colno == keyno + 1)
    1427             :             {
    1428             :                 /* Need parens if it's not a bare function call */
    1429         680 :                 if (looks_like_function(indexkey))
    1430          52 :                     appendStringInfoString(&buf, str);
    1431             :                 else
    1432         628 :                     appendStringInfo(&buf, "(%s)", str);
    1433             :             }
    1434         692 :             keycoltype = exprType(indexkey);
    1435         692 :             keycolcollation = exprCollation(indexkey);
    1436             :         }
    1437             : 
    1438             :         /* Print additional decoration for (selected) key columns */
    1439       11524 :         if (!attrsOnly && keyno < idxrec->indnkeyatts &&
    1440           0 :             (!colno || colno == keyno + 1))
    1441             :         {
    1442        9502 :             int16       opt = indoption->values[keyno];
    1443        9502 :             Oid         indcoll = indcollation->values[keyno];
    1444        9502 :             Datum       attoptions = get_attoptions(indexrelid, keyno + 1);
    1445        9502 :             bool        has_options = attoptions != (Datum) 0;
    1446             : 
    1447             :             /* Add collation, if not default for column */
    1448        9502 :             if (OidIsValid(indcoll) && indcoll != keycolcollation)
    1449          90 :                 appendStringInfo(&buf, " COLLATE %s",
    1450             :                                  generate_collation_name((indcoll)));
    1451             : 
    1452             :             /* Add the operator class name, if not default */
    1453        9502 :             get_opclass_name(indclass->values[keyno],
    1454             :                              has_options ? InvalidOid : keycoltype, &buf);
    1455             : 
    1456        9502 :             if (has_options)
    1457             :             {
    1458          30 :                 appendStringInfoString(&buf, " (");
    1459          30 :                 get_reloptions(&buf, attoptions);
    1460          30 :                 appendStringInfoChar(&buf, ')');
    1461             :             }
    1462             : 
    1463             :             /* Add options if relevant */
    1464        9502 :             if (amroutine->amcanorder)
    1465             :             {
    1466             :                 /* if it supports sort ordering, report DESC and NULLS opts */
    1467        8194 :                 if (opt & INDOPTION_DESC)
    1468             :                 {
    1469           0 :                     appendStringInfoString(&buf, " DESC");
    1470             :                     /* NULLS FIRST is the default in this case */
    1471           0 :                     if (!(opt & INDOPTION_NULLS_FIRST))
    1472           0 :                         appendStringInfoString(&buf, " NULLS LAST");
    1473             :                 }
    1474             :                 else
    1475             :                 {
    1476        8194 :                     if (opt & INDOPTION_NULLS_FIRST)
    1477           0 :                         appendStringInfoString(&buf, " NULLS FIRST");
    1478             :                 }
    1479             :             }
    1480             : 
    1481             :             /* Add the exclusion operator if relevant */
    1482        9502 :             if (excludeOps != NULL)
    1483         124 :                 appendStringInfo(&buf, " WITH %s",
    1484         124 :                                  generate_operator_name(excludeOps[keyno],
    1485             :                                                         keycoltype,
    1486             :                                                         keycoltype));
    1487             :         }
    1488             :     }
    1489             : 
    1490        7704 :     if (!attrsOnly)
    1491             :     {
    1492        6480 :         appendStringInfoChar(&buf, ')');
    1493             : 
    1494        6480 :         if (idxrec->indnullsnotdistinct)
    1495          12 :             appendStringInfoString(&buf, " NULLS NOT DISTINCT");
    1496             : 
    1497             :         /*
    1498             :          * If it has options, append "WITH (options)"
    1499             :          */
    1500        6480 :         str = flatten_reloptions(indexrelid);
    1501        6480 :         if (str)
    1502             :         {
    1503         210 :             appendStringInfo(&buf, " WITH (%s)", str);
    1504         210 :             pfree(str);
    1505             :         }
    1506             : 
    1507             :         /*
    1508             :          * Print tablespace, but only if requested
    1509             :          */
    1510        6480 :         if (showTblSpc)
    1511             :         {
    1512             :             Oid         tblspc;
    1513             : 
    1514         212 :             tblspc = get_rel_tablespace(indexrelid);
    1515         212 :             if (OidIsValid(tblspc))
    1516             :             {
    1517          54 :                 if (isConstraint)
    1518           0 :                     appendStringInfoString(&buf, " USING INDEX");
    1519          54 :                 appendStringInfo(&buf, " TABLESPACE %s",
    1520          54 :                                  quote_identifier(get_tablespace_name(tblspc)));
    1521             :             }
    1522             :         }
    1523             : 
    1524             :         /*
    1525             :          * If it's a partial index, decompile and append the predicate
    1526             :          */
    1527        6480 :         if (!heap_attisnull(ht_idx, Anum_pg_index_indpred, NULL))
    1528             :         {
    1529             :             Node       *node;
    1530             :             Datum       predDatum;
    1531             :             char       *predString;
    1532             : 
    1533             :             /* Convert text string to node tree */
    1534         314 :             predDatum = SysCacheGetAttrNotNull(INDEXRELID, ht_idx,
    1535             :                                                Anum_pg_index_indpred);
    1536         314 :             predString = TextDatumGetCString(predDatum);
    1537         314 :             node = (Node *) stringToNode(predString);
    1538         314 :             pfree(predString);
    1539             : 
    1540             :             /* Deparse */
    1541         314 :             str = deparse_expression_pretty(node, context, false, false,
    1542             :                                             prettyFlags, 0);
    1543         314 :             if (isConstraint)
    1544          42 :                 appendStringInfo(&buf, " WHERE (%s)", str);
    1545             :             else
    1546         272 :                 appendStringInfo(&buf, " WHERE %s", str);
    1547             :         }
    1548             :     }
    1549             : 
    1550             :     /* Clean up */
    1551        7704 :     ReleaseSysCache(ht_idx);
    1552        7704 :     ReleaseSysCache(ht_idxrel);
    1553        7704 :     ReleaseSysCache(ht_am);
    1554             : 
    1555        7704 :     return buf.data;
    1556             : }
    1557             : 
    1558             : /* ----------
    1559             :  * pg_get_querydef
    1560             :  *
    1561             :  * Public entry point to deparse one query parsetree.
    1562             :  * The pretty flags are determined by GET_PRETTY_FLAGS(pretty).
    1563             :  *
    1564             :  * The result is a palloc'd C string.
    1565             :  * ----------
    1566             :  */
    1567             : char *
    1568           0 : pg_get_querydef(Query *query, bool pretty)
    1569             : {
    1570             :     StringInfoData buf;
    1571             :     int         prettyFlags;
    1572             : 
    1573           0 :     prettyFlags = GET_PRETTY_FLAGS(pretty);
    1574             : 
    1575           0 :     initStringInfo(&buf);
    1576             : 
    1577           0 :     get_query_def(query, &buf, NIL, NULL, true,
    1578             :                   prettyFlags, WRAP_COLUMN_DEFAULT, 0);
    1579             : 
    1580           0 :     return buf.data;
    1581             : }
    1582             : 
    1583             : /*
    1584             :  * pg_get_statisticsobjdef
    1585             :  *      Get the definition of an extended statistics object
    1586             :  */
    1587             : Datum
    1588         248 : pg_get_statisticsobjdef(PG_FUNCTION_ARGS)
    1589             : {
    1590         248 :     Oid         statextid = PG_GETARG_OID(0);
    1591             :     char       *res;
    1592             : 
    1593         248 :     res = pg_get_statisticsobj_worker(statextid, false, true);
    1594             : 
    1595         248 :     if (res == NULL)
    1596           6 :         PG_RETURN_NULL();
    1597             : 
    1598         242 :     PG_RETURN_TEXT_P(string_to_text(res));
    1599             : }
    1600             : 
    1601             : /*
    1602             :  * Internal version for use by ALTER TABLE.
    1603             :  * Includes a tablespace clause in the result.
    1604             :  * Returns a palloc'd C string; no pretty-printing.
    1605             :  */
    1606             : char *
    1607          14 : pg_get_statisticsobjdef_string(Oid statextid)
    1608             : {
    1609          14 :     return pg_get_statisticsobj_worker(statextid, false, false);
    1610             : }
    1611             : 
    1612             : /*
    1613             :  * pg_get_statisticsobjdef_columns
    1614             :  *      Get columns and expressions for an extended statistics object
    1615             :  */
    1616             : Datum
    1617         402 : pg_get_statisticsobjdef_columns(PG_FUNCTION_ARGS)
    1618             : {
    1619         402 :     Oid         statextid = PG_GETARG_OID(0);
    1620             :     char       *res;
    1621             : 
    1622         402 :     res = pg_get_statisticsobj_worker(statextid, true, true);
    1623             : 
    1624         402 :     if (res == NULL)
    1625           0 :         PG_RETURN_NULL();
    1626             : 
    1627         402 :     PG_RETURN_TEXT_P(string_to_text(res));
    1628             : }
    1629             : 
    1630             : /*
    1631             :  * Internal workhorse to decompile an extended statistics object.
    1632             :  */
    1633             : static char *
    1634         664 : pg_get_statisticsobj_worker(Oid statextid, bool columns_only, bool missing_ok)
    1635             : {
    1636             :     Form_pg_statistic_ext statextrec;
    1637             :     HeapTuple   statexttup;
    1638             :     StringInfoData buf;
    1639             :     int         colno;
    1640             :     char       *nsp;
    1641             :     ArrayType  *arr;
    1642             :     char       *enabled;
    1643             :     Datum       datum;
    1644             :     bool        ndistinct_enabled;
    1645             :     bool        dependencies_enabled;
    1646             :     bool        mcv_enabled;
    1647             :     int         i;
    1648             :     List       *context;
    1649             :     ListCell   *lc;
    1650         664 :     List       *exprs = NIL;
    1651             :     bool        has_exprs;
    1652             :     int         ncolumns;
    1653             : 
    1654         664 :     statexttup = SearchSysCache1(STATEXTOID, ObjectIdGetDatum(statextid));
    1655             : 
    1656         664 :     if (!HeapTupleIsValid(statexttup))
    1657             :     {
    1658           6 :         if (missing_ok)
    1659           6 :             return NULL;
    1660           0 :         elog(ERROR, "cache lookup failed for statistics object %u", statextid);
    1661             :     }
    1662             : 
    1663             :     /* has the statistics expressions? */
    1664         658 :     has_exprs = !heap_attisnull(statexttup, Anum_pg_statistic_ext_stxexprs, NULL);
    1665             : 
    1666         658 :     statextrec = (Form_pg_statistic_ext) GETSTRUCT(statexttup);
    1667             : 
    1668             :     /*
    1669             :      * Get the statistics expressions, if any.  (NOTE: we do not use the
    1670             :      * relcache versions of the expressions, because we want to display
    1671             :      * non-const-folded expressions.)
    1672             :      */
    1673         658 :     if (has_exprs)
    1674             :     {
    1675             :         Datum       exprsDatum;
    1676             :         char       *exprsString;
    1677             : 
    1678         142 :         exprsDatum = SysCacheGetAttrNotNull(STATEXTOID, statexttup,
    1679             :                                             Anum_pg_statistic_ext_stxexprs);
    1680         142 :         exprsString = TextDatumGetCString(exprsDatum);
    1681         142 :         exprs = (List *) stringToNode(exprsString);
    1682         142 :         pfree(exprsString);
    1683             :     }
    1684             :     else
    1685         516 :         exprs = NIL;
    1686             : 
    1687             :     /* count the number of columns (attributes and expressions) */
    1688         658 :     ncolumns = statextrec->stxkeys.dim1 + list_length(exprs);
    1689             : 
    1690         658 :     initStringInfo(&buf);
    1691             : 
    1692         658 :     if (!columns_only)
    1693             :     {
    1694         256 :         nsp = get_namespace_name_or_temp(statextrec->stxnamespace);
    1695         256 :         appendStringInfo(&buf, "CREATE STATISTICS %s",
    1696             :                          quote_qualified_identifier(nsp,
    1697         256 :                                                     NameStr(statextrec->stxname)));
    1698             : 
    1699             :         /*
    1700             :          * Decode the stxkind column so that we know which stats types to
    1701             :          * print.
    1702             :          */
    1703         256 :         datum = SysCacheGetAttrNotNull(STATEXTOID, statexttup,
    1704             :                                        Anum_pg_statistic_ext_stxkind);
    1705         256 :         arr = DatumGetArrayTypeP(datum);
    1706         256 :         if (ARR_NDIM(arr) != 1 ||
    1707         256 :             ARR_HASNULL(arr) ||
    1708         256 :             ARR_ELEMTYPE(arr) != CHAROID)
    1709           0 :             elog(ERROR, "stxkind is not a 1-D char array");
    1710         256 :         enabled = (char *) ARR_DATA_PTR(arr);
    1711             : 
    1712         256 :         ndistinct_enabled = false;
    1713         256 :         dependencies_enabled = false;
    1714         256 :         mcv_enabled = false;
    1715             : 
    1716         662 :         for (i = 0; i < ARR_DIMS(arr)[0]; i++)
    1717             :         {
    1718         406 :             if (enabled[i] == STATS_EXT_NDISTINCT)
    1719         136 :                 ndistinct_enabled = true;
    1720         270 :             else if (enabled[i] == STATS_EXT_DEPENDENCIES)
    1721          88 :                 dependencies_enabled = true;
    1722         182 :             else if (enabled[i] == STATS_EXT_MCV)
    1723         106 :                 mcv_enabled = true;
    1724             : 
    1725             :             /* ignore STATS_EXT_EXPRESSIONS (it's built automatically) */
    1726             :         }
    1727             : 
    1728             :         /*
    1729             :          * If any option is disabled, then we'll need to append the types
    1730             :          * clause to show which options are enabled.  We omit the types clause
    1731             :          * on purpose when all options are enabled, so a pg_dump/pg_restore
    1732             :          * will create all statistics types on a newer postgres version, if
    1733             :          * the statistics had all options enabled on the original version.
    1734             :          *
    1735             :          * But if the statistics is defined on just a single column, it has to
    1736             :          * be an expression statistics. In that case we don't need to specify
    1737             :          * kinds.
    1738             :          */
    1739         256 :         if ((!ndistinct_enabled || !dependencies_enabled || !mcv_enabled) &&
    1740             :             (ncolumns > 1))
    1741             :         {
    1742         120 :             bool        gotone = false;
    1743             : 
    1744         120 :             appendStringInfoString(&buf, " (");
    1745             : 
    1746         120 :             if (ndistinct_enabled)
    1747             :             {
    1748          66 :                 appendStringInfoString(&buf, "ndistinct");
    1749          66 :                 gotone = true;
    1750             :             }
    1751             : 
    1752         120 :             if (dependencies_enabled)
    1753             :             {
    1754          18 :                 appendStringInfo(&buf, "%sdependencies", gotone ? ", " : "");
    1755          18 :                 gotone = true;
    1756             :             }
    1757             : 
    1758         120 :             if (mcv_enabled)
    1759          36 :                 appendStringInfo(&buf, "%smcv", gotone ? ", " : "");
    1760             : 
    1761         120 :             appendStringInfoChar(&buf, ')');
    1762             :         }
    1763             : 
    1764         256 :         appendStringInfoString(&buf, " ON ");
    1765             :     }
    1766             : 
    1767             :     /* decode simple column references */
    1768        1870 :     for (colno = 0; colno < statextrec->stxkeys.dim1; colno++)
    1769             :     {
    1770        1212 :         AttrNumber  attnum = statextrec->stxkeys.values[colno];
    1771             :         char       *attname;
    1772             : 
    1773        1212 :         if (colno > 0)
    1774         684 :             appendStringInfoString(&buf, ", ");
    1775             : 
    1776        1212 :         attname = get_attname(statextrec->stxrelid, attnum, false);
    1777             : 
    1778        1212 :         appendStringInfoString(&buf, quote_identifier(attname));
    1779             :     }
    1780             : 
    1781         658 :     context = deparse_context_for(get_relation_name(statextrec->stxrelid),
    1782             :                                   statextrec->stxrelid);
    1783             : 
    1784         886 :     foreach(lc, exprs)
    1785             :     {
    1786         228 :         Node       *expr = (Node *) lfirst(lc);
    1787             :         char       *str;
    1788         228 :         int         prettyFlags = PRETTYFLAG_PAREN;
    1789             : 
    1790         228 :         str = deparse_expression_pretty(expr, context, false, false,
    1791             :                                         prettyFlags, 0);
    1792             : 
    1793         228 :         if (colno > 0)
    1794          98 :             appendStringInfoString(&buf, ", ");
    1795             : 
    1796             :         /* Need parens if it's not a bare function call */
    1797         228 :         if (looks_like_function(expr))
    1798          34 :             appendStringInfoString(&buf, str);
    1799             :         else
    1800         194 :             appendStringInfo(&buf, "(%s)", str);
    1801             : 
    1802         228 :         colno++;
    1803             :     }
    1804             : 
    1805         658 :     if (!columns_only)
    1806         256 :         appendStringInfo(&buf, " FROM %s",
    1807             :                          generate_relation_name(statextrec->stxrelid, NIL));
    1808             : 
    1809         658 :     ReleaseSysCache(statexttup);
    1810             : 
    1811         658 :     return buf.data;
    1812             : }
    1813             : 
    1814             : /*
    1815             :  * Generate text array of expressions for statistics object.
    1816             :  */
    1817             : Datum
    1818          24 : pg_get_statisticsobjdef_expressions(PG_FUNCTION_ARGS)
    1819             : {
    1820          24 :     Oid         statextid = PG_GETARG_OID(0);
    1821             :     Form_pg_statistic_ext statextrec;
    1822             :     HeapTuple   statexttup;
    1823             :     Datum       datum;
    1824             :     List       *context;
    1825             :     ListCell   *lc;
    1826          24 :     List       *exprs = NIL;
    1827             :     bool        has_exprs;
    1828             :     char       *tmp;
    1829          24 :     ArrayBuildState *astate = NULL;
    1830             : 
    1831          24 :     statexttup = SearchSysCache1(STATEXTOID, ObjectIdGetDatum(statextid));
    1832             : 
    1833          24 :     if (!HeapTupleIsValid(statexttup))
    1834           0 :         PG_RETURN_NULL();
    1835             : 
    1836             :     /* Does the stats object have expressions? */
    1837          24 :     has_exprs = !heap_attisnull(statexttup, Anum_pg_statistic_ext_stxexprs, NULL);
    1838             : 
    1839             :     /* no expressions? we're done */
    1840          24 :     if (!has_exprs)
    1841             :     {
    1842          12 :         ReleaseSysCache(statexttup);
    1843          12 :         PG_RETURN_NULL();
    1844             :     }
    1845             : 
    1846          12 :     statextrec = (Form_pg_statistic_ext) GETSTRUCT(statexttup);
    1847             : 
    1848             :     /*
    1849             :      * Get the statistics expressions, and deparse them into text values.
    1850             :      */
    1851          12 :     datum = SysCacheGetAttrNotNull(STATEXTOID, statexttup,
    1852             :                                    Anum_pg_statistic_ext_stxexprs);
    1853          12 :     tmp = TextDatumGetCString(datum);
    1854          12 :     exprs = (List *) stringToNode(tmp);
    1855          12 :     pfree(tmp);
    1856             : 
    1857          12 :     context = deparse_context_for(get_relation_name(statextrec->stxrelid),
    1858             :                                   statextrec->stxrelid);
    1859             : 
    1860          36 :     foreach(lc, exprs)
    1861             :     {
    1862          24 :         Node       *expr = (Node *) lfirst(lc);
    1863             :         char       *str;
    1864          24 :         int         prettyFlags = PRETTYFLAG_INDENT;
    1865             : 
    1866          24 :         str = deparse_expression_pretty(expr, context, false, false,
    1867             :                                         prettyFlags, 0);
    1868             : 
    1869          24 :         astate = accumArrayResult(astate,
    1870          24 :                                   PointerGetDatum(cstring_to_text(str)),
    1871             :                                   false,
    1872             :                                   TEXTOID,
    1873             :                                   CurrentMemoryContext);
    1874             :     }
    1875             : 
    1876          12 :     ReleaseSysCache(statexttup);
    1877             : 
    1878          12 :     PG_RETURN_DATUM(makeArrayResult(astate, CurrentMemoryContext));
    1879             : }
    1880             : 
    1881             : /*
    1882             :  * pg_get_partkeydef
    1883             :  *
    1884             :  * Returns the partition key specification, ie, the following:
    1885             :  *
    1886             :  * { RANGE | LIST | HASH } (column opt_collation opt_opclass [, ...])
    1887             :  */
    1888             : Datum
    1889        1278 : pg_get_partkeydef(PG_FUNCTION_ARGS)
    1890             : {
    1891        1278 :     Oid         relid = PG_GETARG_OID(0);
    1892             :     char       *res;
    1893             : 
    1894        1278 :     res = pg_get_partkeydef_worker(relid, PRETTYFLAG_INDENT, false, true);
    1895             : 
    1896        1278 :     if (res == NULL)
    1897           6 :         PG_RETURN_NULL();
    1898             : 
    1899        1272 :     PG_RETURN_TEXT_P(string_to_text(res));
    1900             : }
    1901             : 
    1902             : /* Internal version that just reports the column definitions */
    1903             : char *
    1904         142 : pg_get_partkeydef_columns(Oid relid, bool pretty)
    1905             : {
    1906             :     int         prettyFlags;
    1907             : 
    1908         142 :     prettyFlags = GET_PRETTY_FLAGS(pretty);
    1909             : 
    1910         142 :     return pg_get_partkeydef_worker(relid, prettyFlags, true, false);
    1911             : }
    1912             : 
    1913             : /*
    1914             :  * Internal workhorse to decompile a partition key definition.
    1915             :  */
    1916             : static char *
    1917        1420 : pg_get_partkeydef_worker(Oid relid, int prettyFlags,
    1918             :                          bool attrsOnly, bool missing_ok)
    1919             : {
    1920             :     Form_pg_partitioned_table form;
    1921             :     HeapTuple   tuple;
    1922             :     oidvector  *partclass;
    1923             :     oidvector  *partcollation;
    1924             :     List       *partexprs;
    1925             :     ListCell   *partexpr_item;
    1926             :     List       *context;
    1927             :     Datum       datum;
    1928             :     StringInfoData buf;
    1929             :     int         keyno;
    1930             :     char       *str;
    1931             :     char       *sep;
    1932             : 
    1933        1420 :     tuple = SearchSysCache1(PARTRELID, ObjectIdGetDatum(relid));
    1934        1420 :     if (!HeapTupleIsValid(tuple))
    1935             :     {
    1936           6 :         if (missing_ok)
    1937           6 :             return NULL;
    1938           0 :         elog(ERROR, "cache lookup failed for partition key of %u", relid);
    1939             :     }
    1940             : 
    1941        1414 :     form = (Form_pg_partitioned_table) GETSTRUCT(tuple);
    1942             : 
    1943             :     Assert(form->partrelid == relid);
    1944             : 
    1945             :     /* Must get partclass and partcollation the hard way */
    1946        1414 :     datum = SysCacheGetAttrNotNull(PARTRELID, tuple,
    1947             :                                    Anum_pg_partitioned_table_partclass);
    1948        1414 :     partclass = (oidvector *) DatumGetPointer(datum);
    1949             : 
    1950        1414 :     datum = SysCacheGetAttrNotNull(PARTRELID, tuple,
    1951             :                                    Anum_pg_partitioned_table_partcollation);
    1952        1414 :     partcollation = (oidvector *) DatumGetPointer(datum);
    1953             : 
    1954             : 
    1955             :     /*
    1956             :      * Get the expressions, if any.  (NOTE: we do not use the relcache
    1957             :      * versions of the expressions, because we want to display
    1958             :      * non-const-folded expressions.)
    1959             :      */
    1960        1414 :     if (!heap_attisnull(tuple, Anum_pg_partitioned_table_partexprs, NULL))
    1961             :     {
    1962             :         Datum       exprsDatum;
    1963             :         char       *exprsString;
    1964             : 
    1965         146 :         exprsDatum = SysCacheGetAttrNotNull(PARTRELID, tuple,
    1966             :                                             Anum_pg_partitioned_table_partexprs);
    1967         146 :         exprsString = TextDatumGetCString(exprsDatum);
    1968         146 :         partexprs = (List *) stringToNode(exprsString);
    1969             : 
    1970         146 :         if (!IsA(partexprs, List))
    1971           0 :             elog(ERROR, "unexpected node type found in partexprs: %d",
    1972             :                  (int) nodeTag(partexprs));
    1973             : 
    1974         146 :         pfree(exprsString);
    1975             :     }
    1976             :     else
    1977        1268 :         partexprs = NIL;
    1978             : 
    1979        1414 :     partexpr_item = list_head(partexprs);
    1980        1414 :     context = deparse_context_for(get_relation_name(relid), relid);
    1981             : 
    1982        1414 :     initStringInfo(&buf);
    1983             : 
    1984        1414 :     switch (form->partstrat)
    1985             :     {
    1986          54 :         case PARTITION_STRATEGY_HASH:
    1987          54 :             if (!attrsOnly)
    1988          54 :                 appendStringInfoString(&buf, "HASH");
    1989          54 :             break;
    1990         526 :         case PARTITION_STRATEGY_LIST:
    1991         526 :             if (!attrsOnly)
    1992         486 :                 appendStringInfoString(&buf, "LIST");
    1993         526 :             break;
    1994         834 :         case PARTITION_STRATEGY_RANGE:
    1995         834 :             if (!attrsOnly)
    1996         732 :                 appendStringInfoString(&buf, "RANGE");
    1997         834 :             break;
    1998           0 :         default:
    1999           0 :             elog(ERROR, "unexpected partition strategy: %d",
    2000             :                  (int) form->partstrat);
    2001             :     }
    2002             : 
    2003        1414 :     if (!attrsOnly)
    2004        1272 :         appendStringInfoString(&buf, " (");
    2005        1414 :     sep = "";
    2006        2980 :     for (keyno = 0; keyno < form->partnatts; keyno++)
    2007             :     {
    2008        1566 :         AttrNumber  attnum = form->partattrs.values[keyno];
    2009             :         Oid         keycoltype;
    2010             :         Oid         keycolcollation;
    2011             :         Oid         partcoll;
    2012             : 
    2013        1566 :         appendStringInfoString(&buf, sep);
    2014        1566 :         sep = ", ";
    2015        1566 :         if (attnum != 0)
    2016             :         {
    2017             :             /* Simple attribute reference */
    2018             :             char       *attname;
    2019             :             int32       keycoltypmod;
    2020             : 
    2021        1408 :             attname = get_attname(relid, attnum, false);
    2022        1408 :             appendStringInfoString(&buf, quote_identifier(attname));
    2023        1408 :             get_atttypetypmodcoll(relid, attnum,
    2024             :                                   &keycoltype, &keycoltypmod,
    2025             :                                   &keycolcollation);
    2026             :         }
    2027             :         else
    2028             :         {
    2029             :             /* Expression */
    2030             :             Node       *partkey;
    2031             : 
    2032         158 :             if (partexpr_item == NULL)
    2033           0 :                 elog(ERROR, "too few entries in partexprs list");
    2034         158 :             partkey = (Node *) lfirst(partexpr_item);
    2035         158 :             partexpr_item = lnext(partexprs, partexpr_item);
    2036             : 
    2037             :             /* Deparse */
    2038         158 :             str = deparse_expression_pretty(partkey, context, false, false,
    2039             :                                             prettyFlags, 0);
    2040             :             /* Need parens if it's not a bare function call */
    2041         158 :             if (looks_like_function(partkey))
    2042          56 :                 appendStringInfoString(&buf, str);
    2043             :             else
    2044         102 :                 appendStringInfo(&buf, "(%s)", str);
    2045             : 
    2046         158 :             keycoltype = exprType(partkey);
    2047         158 :             keycolcollation = exprCollation(partkey);
    2048             :         }
    2049             : 
    2050             :         /* Add collation, if not default for column */
    2051        1566 :         partcoll = partcollation->values[keyno];
    2052        1566 :         if (!attrsOnly && OidIsValid(partcoll) && partcoll != keycolcollation)
    2053           6 :             appendStringInfo(&buf, " COLLATE %s",
    2054             :                              generate_collation_name((partcoll)));
    2055             : 
    2056             :         /* Add the operator class name, if not default */
    2057        1566 :         if (!attrsOnly)
    2058        1370 :             get_opclass_name(partclass->values[keyno], keycoltype, &buf);
    2059             :     }
    2060             : 
    2061        1414 :     if (!attrsOnly)
    2062        1272 :         appendStringInfoChar(&buf, ')');
    2063             : 
    2064             :     /* Clean up */
    2065        1414 :     ReleaseSysCache(tuple);
    2066             : 
    2067        1414 :     return buf.data;
    2068             : }
    2069             : 
    2070             : /*
    2071             :  * pg_get_partition_constraintdef
    2072             :  *
    2073             :  * Returns partition constraint expression as a string for the input relation
    2074             :  */
    2075             : Datum
    2076         156 : pg_get_partition_constraintdef(PG_FUNCTION_ARGS)
    2077             : {
    2078         156 :     Oid         relationId = PG_GETARG_OID(0);
    2079             :     Expr       *constr_expr;
    2080             :     int         prettyFlags;
    2081             :     List       *context;
    2082             :     char       *consrc;
    2083             : 
    2084         156 :     constr_expr = get_partition_qual_relid(relationId);
    2085             : 
    2086             :     /* Quick exit if no partition constraint */
    2087         156 :     if (constr_expr == NULL)
    2088          18 :         PG_RETURN_NULL();
    2089             : 
    2090             :     /*
    2091             :      * Deparse and return the constraint expression.
    2092             :      */
    2093         138 :     prettyFlags = PRETTYFLAG_INDENT;
    2094         138 :     context = deparse_context_for(get_relation_name(relationId), relationId);
    2095         138 :     consrc = deparse_expression_pretty((Node *) constr_expr, context, false,
    2096             :                                        false, prettyFlags, 0);
    2097             : 
    2098         138 :     PG_RETURN_TEXT_P(string_to_text(consrc));
    2099             : }
    2100             : 
    2101             : /*
    2102             :  * pg_get_partconstrdef_string
    2103             :  *
    2104             :  * Returns the partition constraint as a C-string for the input relation, with
    2105             :  * the given alias.  No pretty-printing.
    2106             :  */
    2107             : char *
    2108          86 : pg_get_partconstrdef_string(Oid partitionId, char *aliasname)
    2109             : {
    2110             :     Expr       *constr_expr;
    2111             :     List       *context;
    2112             : 
    2113          86 :     constr_expr = get_partition_qual_relid(partitionId);
    2114          86 :     context = deparse_context_for(aliasname, partitionId);
    2115             : 
    2116          86 :     return deparse_expression((Node *) constr_expr, context, true, false);
    2117             : }
    2118             : 
    2119             : /*
    2120             :  * pg_get_constraintdef
    2121             :  *
    2122             :  * Returns the definition for the constraint, ie, everything that needs to
    2123             :  * appear after "ALTER TABLE ... ADD CONSTRAINT <constraintname>".
    2124             :  */
    2125             : Datum
    2126        1620 : pg_get_constraintdef(PG_FUNCTION_ARGS)
    2127             : {
    2128        1620 :     Oid         constraintId = PG_GETARG_OID(0);
    2129             :     int         prettyFlags;
    2130             :     char       *res;
    2131             : 
    2132        1620 :     prettyFlags = PRETTYFLAG_INDENT;
    2133             : 
    2134        1620 :     res = pg_get_constraintdef_worker(constraintId, false, prettyFlags, true);
    2135             : 
    2136        1620 :     if (res == NULL)
    2137           6 :         PG_RETURN_NULL();
    2138             : 
    2139        1614 :     PG_RETURN_TEXT_P(string_to_text(res));
    2140             : }
    2141             : 
    2142             : Datum
    2143        3778 : pg_get_constraintdef_ext(PG_FUNCTION_ARGS)
    2144             : {
    2145        3778 :     Oid         constraintId = PG_GETARG_OID(0);
    2146        3778 :     bool        pretty = PG_GETARG_BOOL(1);
    2147             :     int         prettyFlags;
    2148             :     char       *res;
    2149             : 
    2150        3778 :     prettyFlags = GET_PRETTY_FLAGS(pretty);
    2151             : 
    2152        3778 :     res = pg_get_constraintdef_worker(constraintId, false, prettyFlags, true);
    2153             : 
    2154        3778 :     if (res == NULL)
    2155           0 :         PG_RETURN_NULL();
    2156             : 
    2157        3778 :     PG_RETURN_TEXT_P(string_to_text(res));
    2158             : }
    2159             : 
    2160             : /*
    2161             :  * Internal version that returns a full ALTER TABLE ... ADD CONSTRAINT command
    2162             :  */
    2163             : char *
    2164         374 : pg_get_constraintdef_command(Oid constraintId)
    2165             : {
    2166         374 :     return pg_get_constraintdef_worker(constraintId, true, 0, false);
    2167             : }
    2168             : 
    2169             : /*
    2170             :  * As of 9.4, we now use an MVCC snapshot for this.
    2171             :  */
    2172             : static char *
    2173        5772 : pg_get_constraintdef_worker(Oid constraintId, bool fullCommand,
    2174             :                             int prettyFlags, bool missing_ok)
    2175             : {
    2176             :     HeapTuple   tup;
    2177             :     Form_pg_constraint conForm;
    2178             :     StringInfoData buf;
    2179             :     SysScanDesc scandesc;
    2180             :     ScanKeyData scankey[1];
    2181        5772 :     Snapshot    snapshot = RegisterSnapshot(GetTransactionSnapshot());
    2182        5772 :     Relation    relation = table_open(ConstraintRelationId, AccessShareLock);
    2183             : 
    2184        5772 :     ScanKeyInit(&scankey[0],
    2185             :                 Anum_pg_constraint_oid,
    2186             :                 BTEqualStrategyNumber, F_OIDEQ,
    2187             :                 ObjectIdGetDatum(constraintId));
    2188             : 
    2189        5772 :     scandesc = systable_beginscan(relation,
    2190             :                                   ConstraintOidIndexId,
    2191             :                                   true,
    2192             :                                   snapshot,
    2193             :                                   1,
    2194             :                                   scankey);
    2195             : 
    2196             :     /*
    2197             :      * We later use the tuple with SysCacheGetAttr() as if we had obtained it
    2198             :      * via SearchSysCache, which works fine.
    2199             :      */
    2200        5772 :     tup = systable_getnext(scandesc);
    2201             : 
    2202        5772 :     UnregisterSnapshot(snapshot);
    2203             : 
    2204        5772 :     if (!HeapTupleIsValid(tup))
    2205             :     {
    2206           6 :         if (missing_ok)
    2207             :         {
    2208           6 :             systable_endscan(scandesc);
    2209           6 :             table_close(relation, AccessShareLock);
    2210           6 :             return NULL;
    2211             :         }
    2212           0 :         elog(ERROR, "could not find tuple for constraint %u", constraintId);
    2213             :     }
    2214             : 
    2215        5766 :     conForm = (Form_pg_constraint) GETSTRUCT(tup);
    2216             : 
    2217        5766 :     initStringInfo(&buf);
    2218             : 
    2219        5766 :     if (fullCommand)
    2220             :     {
    2221         374 :         if (OidIsValid(conForm->conrelid))
    2222             :         {
    2223             :             /*
    2224             :              * Currently, callers want ALTER TABLE (without ONLY) for CHECK
    2225             :              * constraints, and other types of constraints don't inherit
    2226             :              * anyway so it doesn't matter whether we say ONLY or not. Someday
    2227             :              * we might need to let callers specify whether to put ONLY in the
    2228             :              * command.
    2229             :              */
    2230         360 :             appendStringInfo(&buf, "ALTER TABLE %s ADD CONSTRAINT %s ",
    2231             :                              generate_qualified_relation_name(conForm->conrelid),
    2232         360 :                              quote_identifier(NameStr(conForm->conname)));
    2233             :         }
    2234             :         else
    2235             :         {
    2236             :             /* Must be a domain constraint */
    2237             :             Assert(OidIsValid(conForm->contypid));
    2238          14 :             appendStringInfo(&buf, "ALTER DOMAIN %s ADD CONSTRAINT %s ",
    2239             :                              generate_qualified_type_name(conForm->contypid),
    2240          14 :                              quote_identifier(NameStr(conForm->conname)));
    2241             :         }
    2242             :     }
    2243             : 
    2244        5766 :     switch (conForm->contype)
    2245             :     {
    2246         628 :         case CONSTRAINT_FOREIGN:
    2247             :             {
    2248             :                 Datum       val;
    2249             :                 bool        isnull;
    2250             :                 const char *string;
    2251             : 
    2252             :                 /* Start off the constraint definition */
    2253         628 :                 appendStringInfoString(&buf, "FOREIGN KEY (");
    2254             : 
    2255             :                 /* Fetch and build referencing-column list */
    2256         628 :                 val = SysCacheGetAttrNotNull(CONSTROID, tup,
    2257             :                                              Anum_pg_constraint_conkey);
    2258             : 
    2259         628 :                 decompile_column_index_array(val, conForm->conrelid, &buf);
    2260             : 
    2261             :                 /* add foreign relation name */
    2262         628 :                 appendStringInfo(&buf, ") REFERENCES %s(",
    2263             :                                  generate_relation_name(conForm->confrelid,
    2264             :                                                         NIL));
    2265             : 
    2266             :                 /* Fetch and build referenced-column list */
    2267         628 :                 val = SysCacheGetAttrNotNull(CONSTROID, tup,
    2268             :                                              Anum_pg_constraint_confkey);
    2269             : 
    2270         628 :                 decompile_column_index_array(val, conForm->confrelid, &buf);
    2271             : 
    2272         628 :                 appendStringInfoChar(&buf, ')');
    2273             : 
    2274             :                 /* Add match type */
    2275         628 :                 switch (conForm->confmatchtype)
    2276             :                 {
    2277          34 :                     case FKCONSTR_MATCH_FULL:
    2278          34 :                         string = " MATCH FULL";
    2279          34 :                         break;
    2280           0 :                     case FKCONSTR_MATCH_PARTIAL:
    2281           0 :                         string = " MATCH PARTIAL";
    2282           0 :                         break;
    2283         594 :                     case FKCONSTR_MATCH_SIMPLE:
    2284         594 :                         string = "";
    2285         594 :                         break;
    2286           0 :                     default:
    2287           0 :                         elog(ERROR, "unrecognized confmatchtype: %d",
    2288             :                              conForm->confmatchtype);
    2289             :                         string = "";  /* keep compiler quiet */
    2290             :                         break;
    2291             :                 }
    2292         628 :                 appendStringInfoString(&buf, string);
    2293             : 
    2294             :                 /* Add ON UPDATE and ON DELETE clauses, if needed */
    2295         628 :                 switch (conForm->confupdtype)
    2296             :                 {
    2297         504 :                     case FKCONSTR_ACTION_NOACTION:
    2298         504 :                         string = NULL;  /* suppress default */
    2299         504 :                         break;
    2300           0 :                     case FKCONSTR_ACTION_RESTRICT:
    2301           0 :                         string = "RESTRICT";
    2302           0 :                         break;
    2303          96 :                     case FKCONSTR_ACTION_CASCADE:
    2304          96 :                         string = "CASCADE";
    2305          96 :                         break;
    2306          28 :                     case FKCONSTR_ACTION_SETNULL:
    2307          28 :                         string = "SET NULL";
    2308          28 :                         break;
    2309           0 :                     case FKCONSTR_ACTION_SETDEFAULT:
    2310           0 :                         string = "SET DEFAULT";
    2311           0 :                         break;
    2312           0 :                     default:
    2313           0 :                         elog(ERROR, "unrecognized confupdtype: %d",
    2314             :                              conForm->confupdtype);
    2315             :                         string = NULL;  /* keep compiler quiet */
    2316             :                         break;
    2317             :                 }
    2318         628 :                 if (string)
    2319         124 :                     appendStringInfo(&buf, " ON UPDATE %s", string);
    2320             : 
    2321         628 :                 switch (conForm->confdeltype)
    2322             :                 {
    2323         508 :                     case FKCONSTR_ACTION_NOACTION:
    2324         508 :                         string = NULL;  /* suppress default */
    2325         508 :                         break;
    2326           0 :                     case FKCONSTR_ACTION_RESTRICT:
    2327           0 :                         string = "RESTRICT";
    2328           0 :                         break;
    2329          96 :                     case FKCONSTR_ACTION_CASCADE:
    2330          96 :                         string = "CASCADE";
    2331          96 :                         break;
    2332          18 :                     case FKCONSTR_ACTION_SETNULL:
    2333          18 :                         string = "SET NULL";
    2334          18 :                         break;
    2335           6 :                     case FKCONSTR_ACTION_SETDEFAULT:
    2336           6 :                         string = "SET DEFAULT";
    2337           6 :                         break;
    2338           0 :                     default:
    2339           0 :                         elog(ERROR, "unrecognized confdeltype: %d",
    2340             :                              conForm->confdeltype);
    2341             :                         string = NULL;  /* keep compiler quiet */
    2342             :                         break;
    2343             :                 }
    2344         628 :                 if (string)
    2345         120 :                     appendStringInfo(&buf, " ON DELETE %s", string);
    2346             : 
    2347             :                 /*
    2348             :                  * Add columns specified to SET NULL or SET DEFAULT if
    2349             :                  * provided.
    2350             :                  */
    2351         628 :                 val = SysCacheGetAttr(CONSTROID, tup,
    2352             :                                       Anum_pg_constraint_confdelsetcols, &isnull);
    2353         628 :                 if (!isnull)
    2354             :                 {
    2355          12 :                     appendStringInfoString(&buf, " (");
    2356          12 :                     decompile_column_index_array(val, conForm->conrelid, &buf);
    2357          12 :                     appendStringInfoChar(&buf, ')');
    2358             :                 }
    2359             : 
    2360         628 :                 break;
    2361             :             }
    2362        3086 :         case CONSTRAINT_PRIMARY:
    2363             :         case CONSTRAINT_UNIQUE:
    2364             :             {
    2365             :                 Datum       val;
    2366             :                 Oid         indexId;
    2367             :                 int         keyatts;
    2368             :                 HeapTuple   indtup;
    2369             : 
    2370             :                 /* Start off the constraint definition */
    2371        3086 :                 if (conForm->contype == CONSTRAINT_PRIMARY)
    2372        2500 :                     appendStringInfoString(&buf, "PRIMARY KEY ");
    2373             :                 else
    2374         586 :                     appendStringInfoString(&buf, "UNIQUE ");
    2375             : 
    2376        3086 :                 indexId = conForm->conindid;
    2377             : 
    2378        3086 :                 indtup = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexId));
    2379        3086 :                 if (!HeapTupleIsValid(indtup))
    2380           0 :                     elog(ERROR, "cache lookup failed for index %u", indexId);
    2381        3086 :                 if (conForm->contype == CONSTRAINT_UNIQUE &&
    2382         586 :                     ((Form_pg_index) GETSTRUCT(indtup))->indnullsnotdistinct)
    2383           0 :                     appendStringInfoString(&buf, "NULLS NOT DISTINCT ");
    2384             : 
    2385        3086 :                 appendStringInfoChar(&buf, '(');
    2386             : 
    2387             :                 /* Fetch and build target column list */
    2388        3086 :                 val = SysCacheGetAttrNotNull(CONSTROID, tup,
    2389             :                                              Anum_pg_constraint_conkey);
    2390             : 
    2391        3086 :                 keyatts = decompile_column_index_array(val, conForm->conrelid, &buf);
    2392             : 
    2393        3086 :                 appendStringInfoChar(&buf, ')');
    2394             : 
    2395             :                 /* Build including column list (from pg_index.indkeys) */
    2396        3086 :                 val = SysCacheGetAttrNotNull(INDEXRELID, indtup,
    2397             :                                              Anum_pg_index_indnatts);
    2398        3086 :                 if (DatumGetInt32(val) > keyatts)
    2399             :                 {
    2400             :                     Datum       cols;
    2401             :                     Datum      *keys;
    2402             :                     int         nKeys;
    2403             :                     int         j;
    2404             : 
    2405          82 :                     appendStringInfoString(&buf, " INCLUDE (");
    2406             : 
    2407          82 :                     cols = SysCacheGetAttrNotNull(INDEXRELID, indtup,
    2408             :                                                   Anum_pg_index_indkey);
    2409             : 
    2410          82 :                     deconstruct_array_builtin(DatumGetArrayTypeP(cols), INT2OID,
    2411             :                                               &keys, NULL, &nKeys);
    2412             : 
    2413         246 :                     for (j = keyatts; j < nKeys; j++)
    2414             :                     {
    2415             :                         char       *colName;
    2416             : 
    2417         164 :                         colName = get_attname(conForm->conrelid,
    2418         164 :                                               DatumGetInt16(keys[j]), false);
    2419         164 :                         if (j > keyatts)
    2420          82 :                             appendStringInfoString(&buf, ", ");
    2421         164 :                         appendStringInfoString(&buf, quote_identifier(colName));
    2422             :                     }
    2423             : 
    2424          82 :                     appendStringInfoChar(&buf, ')');
    2425             :                 }
    2426        3086 :                 ReleaseSysCache(indtup);
    2427             : 
    2428             :                 /* XXX why do we only print these bits if fullCommand? */
    2429        3086 :                 if (fullCommand && OidIsValid(indexId))
    2430             :                 {
    2431         180 :                     char       *options = flatten_reloptions(indexId);
    2432             :                     Oid         tblspc;
    2433             : 
    2434         180 :                     if (options)
    2435             :                     {
    2436           0 :                         appendStringInfo(&buf, " WITH (%s)", options);
    2437           0 :                         pfree(options);
    2438             :                     }
    2439             : 
    2440             :                     /*
    2441             :                      * Print the tablespace, unless it's the database default.
    2442             :                      * This is to help ALTER TABLE usage of this facility,
    2443             :                      * which needs this behavior to recreate exact catalog
    2444             :                      * state.
    2445             :                      */
    2446         180 :                     tblspc = get_rel_tablespace(indexId);
    2447         180 :                     if (OidIsValid(tblspc))
    2448          24 :                         appendStringInfo(&buf, " USING INDEX TABLESPACE %s",
    2449          24 :                                          quote_identifier(get_tablespace_name(tblspc)));
    2450             :                 }
    2451             : 
    2452        3086 :                 break;
    2453             :             }
    2454        1948 :         case CONSTRAINT_CHECK:
    2455             :             {
    2456             :                 Datum       val;
    2457             :                 char       *conbin;
    2458             :                 char       *consrc;
    2459             :                 Node       *expr;
    2460             :                 List       *context;
    2461             : 
    2462             :                 /* Fetch constraint expression in parsetree form */
    2463        1948 :                 val = SysCacheGetAttrNotNull(CONSTROID, tup,
    2464             :                                              Anum_pg_constraint_conbin);
    2465             : 
    2466        1948 :                 conbin = TextDatumGetCString(val);
    2467        1948 :                 expr = stringToNode(conbin);
    2468             : 
    2469             :                 /* Set up deparsing context for Var nodes in constraint */
    2470        1948 :                 if (conForm->conrelid != InvalidOid)
    2471             :                 {
    2472             :                     /* relation constraint */
    2473        1740 :                     context = deparse_context_for(get_relation_name(conForm->conrelid),
    2474             :                                                   conForm->conrelid);
    2475             :                 }
    2476             :                 else
    2477             :                 {
    2478             :                     /* domain constraint --- can't have Vars */
    2479         208 :                     context = NIL;
    2480             :                 }
    2481             : 
    2482        1948 :                 consrc = deparse_expression_pretty(expr, context, false, false,
    2483             :                                                    prettyFlags, 0);
    2484             : 
    2485             :                 /*
    2486             :                  * Now emit the constraint definition, adding NO INHERIT if
    2487             :                  * necessary.
    2488             :                  *
    2489             :                  * There are cases where the constraint expression will be
    2490             :                  * fully parenthesized and we don't need the outer parens ...
    2491             :                  * but there are other cases where we do need 'em.  Be
    2492             :                  * conservative for now.
    2493             :                  *
    2494             :                  * Note that simply checking for leading '(' and trailing ')'
    2495             :                  * would NOT be good enough, consider "(x > 0) AND (y > 0)".
    2496             :                  */
    2497        1948 :                 appendStringInfo(&buf, "CHECK (%s)%s",
    2498             :                                  consrc,
    2499        1948 :                                  conForm->connoinherit ? " NO INHERIT" : "");
    2500        1948 :                 break;
    2501             :             }
    2502           0 :         case CONSTRAINT_TRIGGER:
    2503             : 
    2504             :             /*
    2505             :              * There isn't an ALTER TABLE syntax for creating a user-defined
    2506             :              * constraint trigger, but it seems better to print something than
    2507             :              * throw an error; if we throw error then this function couldn't
    2508             :              * safely be applied to all rows of pg_constraint.
    2509             :              */
    2510           0 :             appendStringInfoString(&buf, "TRIGGER");
    2511           0 :             break;
    2512         104 :         case CONSTRAINT_EXCLUSION:
    2513             :             {
    2514         104 :                 Oid         indexOid = conForm->conindid;
    2515             :                 Datum       val;
    2516             :                 Datum      *elems;
    2517             :                 int         nElems;
    2518             :                 int         i;
    2519             :                 Oid        *operators;
    2520             : 
    2521             :                 /* Extract operator OIDs from the pg_constraint tuple */
    2522         104 :                 val = SysCacheGetAttrNotNull(CONSTROID, tup,
    2523             :                                              Anum_pg_constraint_conexclop);
    2524             : 
    2525         104 :                 deconstruct_array_builtin(DatumGetArrayTypeP(val), OIDOID,
    2526             :                                           &elems, NULL, &nElems);
    2527             : 
    2528         104 :                 operators = (Oid *) palloc(nElems * sizeof(Oid));
    2529         228 :                 for (i = 0; i < nElems; i++)
    2530         124 :                     operators[i] = DatumGetObjectId(elems[i]);
    2531             : 
    2532             :                 /* pg_get_indexdef_worker does the rest */
    2533             :                 /* suppress tablespace because pg_dump wants it that way */
    2534         104 :                 appendStringInfoString(&buf,
    2535         104 :                                        pg_get_indexdef_worker(indexOid,
    2536             :                                                               0,
    2537             :                                                               operators,
    2538             :                                                               false,
    2539             :                                                               false,
    2540             :                                                               false,
    2541             :                                                               false,
    2542             :                                                               prettyFlags,
    2543             :                                                               false));
    2544         104 :                 break;
    2545             :             }
    2546           0 :         default:
    2547           0 :             elog(ERROR, "invalid constraint type \"%c\"", conForm->contype);
    2548             :             break;
    2549             :     }
    2550             : 
    2551        5766 :     if (conForm->condeferrable)
    2552          40 :         appendStringInfoString(&buf, " DEFERRABLE");
    2553        5766 :     if (conForm->condeferred)
    2554           0 :         appendStringInfoString(&buf, " INITIALLY DEFERRED");
    2555        5766 :     if (!conForm->convalidated)
    2556          94 :         appendStringInfoString(&buf, " NOT VALID");
    2557             : 
    2558             :     /* Cleanup */
    2559        5766 :     systable_endscan(scandesc);
    2560        5766 :     table_close(relation, AccessShareLock);
    2561             : 
    2562        5766 :     return buf.data;
    2563             : }
    2564             : 
    2565             : 
    2566             : /*
    2567             :  * Convert an int16[] Datum into a comma-separated list of column names
    2568             :  * for the indicated relation; append the list to buf.  Returns the number
    2569             :  * of keys.
    2570             :  */
    2571             : static int
    2572        4354 : decompile_column_index_array(Datum column_index_array, Oid relId,
    2573             :                              StringInfo buf)
    2574             : {
    2575             :     Datum      *keys;
    2576             :     int         nKeys;
    2577             :     int         j;
    2578             : 
    2579             :     /* Extract data from array of int16 */
    2580        4354 :     deconstruct_array_builtin(DatumGetArrayTypeP(column_index_array), INT2OID,
    2581             :                               &keys, NULL, &nKeys);
    2582             : 
    2583       10224 :     for (j = 0; j < nKeys; j++)
    2584             :     {
    2585             :         char       *colName;
    2586             : 
    2587        5870 :         colName = get_attname(relId, DatumGetInt16(keys[j]), false);
    2588             : 
    2589        5870 :         if (j == 0)
    2590        4354 :             appendStringInfoString(buf, quote_identifier(colName));
    2591             :         else
    2592        1516 :             appendStringInfo(buf, ", %s", quote_identifier(colName));
    2593             :     }
    2594             : 
    2595        4354 :     return nKeys;
    2596             : }
    2597             : 
    2598             : 
    2599             : /* ----------
    2600             :  * pg_get_expr          - Decompile an expression tree
    2601             :  *
    2602             :  * Input: an expression tree in nodeToString form, and a relation OID
    2603             :  *
    2604             :  * Output: reverse-listed expression
    2605             :  *
    2606             :  * Currently, the expression can only refer to a single relation, namely
    2607             :  * the one specified by the second parameter.  This is sufficient for
    2608             :  * partial indexes, column default expressions, etc.  We also support
    2609             :  * Var-free expressions, for which the OID can be InvalidOid.
    2610             :  *
    2611             :  * If the OID is nonzero but not actually valid, don't throw an error,
    2612             :  * just return NULL.  This is a bit questionable, but it's what we've
    2613             :  * done historically, and it can help avoid unwanted failures when
    2614             :  * examining catalog entries for just-deleted relations.
    2615             :  *
    2616             :  * We expect this function to work, or throw a reasonably clean error,
    2617             :  * for any node tree that can appear in a catalog pg_node_tree column.
    2618             :  * Query trees, such as those appearing in pg_rewrite.ev_action, are
    2619             :  * not supported.  Nor are expressions in more than one relation, which
    2620             :  * can appear in places like pg_rewrite.ev_qual.
    2621             :  * ----------
    2622             :  */
    2623             : Datum
    2624        7050 : pg_get_expr(PG_FUNCTION_ARGS)
    2625             : {
    2626        7050 :     text       *expr = PG_GETARG_TEXT_PP(0);
    2627        7050 :     Oid         relid = PG_GETARG_OID(1);
    2628             :     text       *result;
    2629             :     int         prettyFlags;
    2630             : 
    2631        7050 :     prettyFlags = PRETTYFLAG_INDENT;
    2632             : 
    2633        7050 :     result = pg_get_expr_worker(expr, relid, prettyFlags);
    2634        7050 :     if (result)
    2635        7046 :         PG_RETURN_TEXT_P(result);
    2636             :     else
    2637           4 :         PG_RETURN_NULL();
    2638             : }
    2639             : 
    2640             : Datum
    2641         478 : pg_get_expr_ext(PG_FUNCTION_ARGS)
    2642             : {
    2643         478 :     text       *expr = PG_GETARG_TEXT_PP(0);
    2644         478 :     Oid         relid = PG_GETARG_OID(1);
    2645         478 :     bool        pretty = PG_GETARG_BOOL(2);
    2646             :     text       *result;
    2647             :     int         prettyFlags;
    2648             : 
    2649         478 :     prettyFlags = GET_PRETTY_FLAGS(pretty);
    2650             : 
    2651         478 :     result = pg_get_expr_worker(expr, relid, prettyFlags);
    2652         478 :     if (result)
    2653         478 :         PG_RETURN_TEXT_P(result);
    2654             :     else
    2655           0 :         PG_RETURN_NULL();
    2656             : }
    2657             : 
    2658             : static text *
    2659        7528 : pg_get_expr_worker(text *expr, Oid relid, int prettyFlags)
    2660             : {
    2661             :     Node       *node;
    2662             :     Node       *tst;
    2663             :     Relids      relids;
    2664             :     List       *context;
    2665             :     char       *exprstr;
    2666        7528 :     Relation    rel = NULL;
    2667             :     char       *str;
    2668             : 
    2669             :     /* Convert input pg_node_tree (really TEXT) object to C string */
    2670        7528 :     exprstr = text_to_cstring(expr);
    2671             : 
    2672             :     /* Convert expression to node tree */
    2673        7528 :     node = (Node *) stringToNode(exprstr);
    2674             : 
    2675        7528 :     pfree(exprstr);
    2676             : 
    2677             :     /*
    2678             :      * Throw error if the input is a querytree rather than an expression tree.
    2679             :      * While we could support queries here, there seems no very good reason
    2680             :      * to.  In most such catalog columns, we'll see a List of Query nodes, or
    2681             :      * even nested Lists, so drill down to a non-List node before checking.
    2682             :      */
    2683        7528 :     tst = node;
    2684        7528 :     while (tst && IsA(tst, List))
    2685           0 :         tst = linitial((List *) tst);
    2686        7528 :     if (tst && IsA(tst, Query))
    2687           0 :         ereport(ERROR,
    2688             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    2689             :                  errmsg("input is a query, not an expression")));
    2690             : 
    2691             :     /*
    2692             :      * Throw error if the expression contains Vars we won't be able to
    2693             :      * deparse.
    2694             :      */
    2695        7528 :     relids = pull_varnos(NULL, node);
    2696        7528 :     if (OidIsValid(relid))
    2697             :     {
    2698        7466 :         if (!bms_is_subset(relids, bms_make_singleton(1)))
    2699           0 :             ereport(ERROR,
    2700             :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    2701             :                      errmsg("expression contains variables of more than one relation")));
    2702             :     }
    2703             :     else
    2704             :     {
    2705          62 :         if (!bms_is_empty(relids))
    2706           0 :             ereport(ERROR,
    2707             :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    2708             :                      errmsg("expression contains variables")));
    2709             :     }
    2710             : 
    2711             :     /*
    2712             :      * Prepare deparse context if needed.  If we are deparsing with a relid,
    2713             :      * we need to transiently open and lock the rel, to make sure it won't go
    2714             :      * away underneath us.  (set_relation_column_names would lock it anyway,
    2715             :      * so this isn't really introducing any new behavior.)
    2716             :      */
    2717        7528 :     if (OidIsValid(relid))
    2718             :     {
    2719        7466 :         rel = try_relation_open(relid, AccessShareLock);
    2720        7466 :         if (rel == NULL)
    2721           4 :             return NULL;
    2722        7462 :         context = deparse_context_for(RelationGetRelationName(rel), relid);
    2723             :     }
    2724             :     else
    2725          62 :         context = NIL;
    2726             : 
    2727             :     /* Deparse */
    2728        7524 :     str = deparse_expression_pretty(node, context, false, false,
    2729             :                                     prettyFlags, 0);
    2730             : 
    2731        7524 :     if (rel != NULL)
    2732        7462 :         relation_close(rel, AccessShareLock);
    2733             : 
    2734        7524 :     return string_to_text(str);
    2735             : }
    2736             : 
    2737             : 
    2738             : /* ----------
    2739             :  * pg_get_userbyid      - Get a user name by roleid and
    2740             :  *                fallback to 'unknown (OID=n)'
    2741             :  * ----------
    2742             :  */
    2743             : Datum
    2744        1616 : pg_get_userbyid(PG_FUNCTION_ARGS)
    2745             : {
    2746        1616 :     Oid         roleid = PG_GETARG_OID(0);
    2747             :     Name        result;
    2748             :     HeapTuple   roletup;
    2749             :     Form_pg_authid role_rec;
    2750             : 
    2751             :     /*
    2752             :      * Allocate space for the result
    2753             :      */
    2754        1616 :     result = (Name) palloc(NAMEDATALEN);
    2755        1616 :     memset(NameStr(*result), 0, NAMEDATALEN);
    2756             : 
    2757             :     /*
    2758             :      * Get the pg_authid entry and print the result
    2759             :      */
    2760        1616 :     roletup = SearchSysCache1(AUTHOID, ObjectIdGetDatum(roleid));
    2761        1616 :     if (HeapTupleIsValid(roletup))
    2762             :     {
    2763        1616 :         role_rec = (Form_pg_authid) GETSTRUCT(roletup);
    2764        1616 :         *result = role_rec->rolname;
    2765        1616 :         ReleaseSysCache(roletup);
    2766             :     }
    2767             :     else
    2768           0 :         sprintf(NameStr(*result), "unknown (OID=%u)", roleid);
    2769             : 
    2770        1616 :     PG_RETURN_NAME(result);
    2771             : }
    2772             : 
    2773             : 
    2774             : /*
    2775             :  * pg_get_serial_sequence
    2776             :  *      Get the name of the sequence used by an identity or serial column,
    2777             :  *      formatted suitably for passing to setval, nextval or currval.
    2778             :  *      First parameter is not treated as double-quoted, second parameter
    2779             :  *      is --- see documentation for reason.
    2780             :  */
    2781             : Datum
    2782          12 : pg_get_serial_sequence(PG_FUNCTION_ARGS)
    2783             : {
    2784          12 :     text       *tablename = PG_GETARG_TEXT_PP(0);
    2785          12 :     text       *columnname = PG_GETARG_TEXT_PP(1);
    2786             :     RangeVar   *tablerv;
    2787             :     Oid         tableOid;
    2788             :     char       *column;
    2789             :     AttrNumber  attnum;
    2790          12 :     Oid         sequenceId = InvalidOid;
    2791             :     Relation    depRel;
    2792             :     ScanKeyData key[3];
    2793             :     SysScanDesc scan;
    2794             :     HeapTuple   tup;
    2795             : 
    2796             :     /* Look up table name.  Can't lock it - we might not have privileges. */
    2797          12 :     tablerv = makeRangeVarFromNameList(textToQualifiedNameList(tablename));
    2798          12 :     tableOid = RangeVarGetRelid(tablerv, NoLock, false);
    2799             : 
    2800             :     /* Get the number of the column */
    2801          12 :     column = text_to_cstring(columnname);
    2802             : 
    2803          12 :     attnum = get_attnum(tableOid, column);
    2804          12 :     if (attnum == InvalidAttrNumber)
    2805           0 :         ereport(ERROR,
    2806             :                 (errcode(ERRCODE_UNDEFINED_COLUMN),
    2807             :                  errmsg("column \"%s\" of relation \"%s\" does not exist",
    2808             :                         column, tablerv->relname)));
    2809             : 
    2810             :     /* Search the dependency table for the dependent sequence */
    2811          12 :     depRel = table_open(DependRelationId, AccessShareLock);
    2812             : 
    2813          12 :     ScanKeyInit(&key[0],
    2814             :                 Anum_pg_depend_refclassid,
    2815             :                 BTEqualStrategyNumber, F_OIDEQ,
    2816             :                 ObjectIdGetDatum(RelationRelationId));
    2817          12 :     ScanKeyInit(&key[1],
    2818             :                 Anum_pg_depend_refobjid,
    2819             :                 BTEqualStrategyNumber, F_OIDEQ,
    2820             :                 ObjectIdGetDatum(tableOid));
    2821          12 :     ScanKeyInit(&key[2],
    2822             :                 Anum_pg_depend_refobjsubid,
    2823             :                 BTEqualStrategyNumber, F_INT4EQ,
    2824             :                 Int32GetDatum(attnum));
    2825             : 
    2826          12 :     scan = systable_beginscan(depRel, DependReferenceIndexId, true,
    2827             :                               NULL, 3, key);
    2828             : 
    2829          18 :     while (HeapTupleIsValid(tup = systable_getnext(scan)))
    2830             :     {
    2831          18 :         Form_pg_depend deprec = (Form_pg_depend) GETSTRUCT(tup);
    2832             : 
    2833             :         /*
    2834             :          * Look for an auto dependency (serial column) or internal dependency
    2835             :          * (identity column) of a sequence on a column.  (We need the relkind
    2836             :          * test because indexes can also have auto dependencies on columns.)
    2837             :          */
    2838          18 :         if (deprec->classid == RelationRelationId &&
    2839          12 :             deprec->objsubid == 0 &&
    2840          12 :             (deprec->deptype == DEPENDENCY_AUTO ||
    2841          18 :              deprec->deptype == DEPENDENCY_INTERNAL) &&
    2842          12 :             get_rel_relkind(deprec->objid) == RELKIND_SEQUENCE)
    2843             :         {
    2844          12 :             sequenceId = deprec->objid;
    2845          12 :             break;
    2846             :         }
    2847             :     }
    2848             : 
    2849          12 :     systable_endscan(scan);
    2850          12 :     table_close(depRel, AccessShareLock);
    2851             : 
    2852          12 :     if (OidIsValid(sequenceId))
    2853             :     {
    2854             :         char       *result;
    2855             : 
    2856          12 :         result = generate_qualified_relation_name(sequenceId);
    2857             : 
    2858          12 :         PG_RETURN_TEXT_P(string_to_text(result));
    2859             :     }
    2860             : 
    2861           0 :     PG_RETURN_NULL();
    2862             : }
    2863             : 
    2864             : 
    2865             : /*
    2866             :  * pg_get_functiondef
    2867             :  *      Returns the complete "CREATE OR REPLACE FUNCTION ..." statement for
    2868             :  *      the specified function.
    2869             :  *
    2870             :  * Note: if you change the output format of this function, be careful not
    2871             :  * to break psql's rules (in \ef and \sf) for identifying the start of the
    2872             :  * function body.  To wit: the function body starts on a line that begins with
    2873             :  * "AS ", "BEGIN ", or "RETURN ", and no preceding line will look like that.
    2874             :  */
    2875             : Datum
    2876         166 : pg_get_functiondef(PG_FUNCTION_ARGS)
    2877             : {
    2878         166 :     Oid         funcid = PG_GETARG_OID(0);
    2879             :     StringInfoData buf;
    2880             :     StringInfoData dq;
    2881             :     HeapTuple   proctup;
    2882             :     Form_pg_proc proc;
    2883             :     bool        isfunction;
    2884             :     Datum       tmp;
    2885             :     bool        isnull;
    2886             :     const char *prosrc;
    2887             :     const char *name;
    2888             :     const char *nsp;
    2889             :     float4      procost;
    2890             :     int         oldlen;
    2891             : 
    2892         166 :     initStringInfo(&buf);
    2893             : 
    2894             :     /* Look up the function */
    2895         166 :     proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    2896         166 :     if (!HeapTupleIsValid(proctup))
    2897           6 :         PG_RETURN_NULL();
    2898             : 
    2899         160 :     proc = (Form_pg_proc) GETSTRUCT(proctup);
    2900         160 :     name = NameStr(proc->proname);
    2901             : 
    2902         160 :     if (proc->prokind == PROKIND_AGGREGATE)
    2903           0 :         ereport(ERROR,
    2904             :                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
    2905             :                  errmsg("\"%s\" is an aggregate function", name)));
    2906             : 
    2907         160 :     isfunction = (proc->prokind != PROKIND_PROCEDURE);
    2908             : 
    2909             :     /*
    2910             :      * We always qualify the function name, to ensure the right function gets
    2911             :      * replaced.
    2912             :      */
    2913         160 :     nsp = get_namespace_name_or_temp(proc->pronamespace);
    2914         160 :     appendStringInfo(&buf, "CREATE OR REPLACE %s %s(",
    2915             :                      isfunction ? "FUNCTION" : "PROCEDURE",
    2916             :                      quote_qualified_identifier(nsp, name));
    2917         160 :     (void) print_function_arguments(&buf, proctup, false, true);
    2918         160 :     appendStringInfoString(&buf, ")\n");
    2919         160 :     if (isfunction)
    2920             :     {
    2921         140 :         appendStringInfoString(&buf, " RETURNS ");
    2922         140 :         print_function_rettype(&buf, proctup);
    2923         140 :         appendStringInfoChar(&buf, '\n');
    2924             :     }
    2925             : 
    2926         160 :     print_function_trftypes(&buf, proctup);
    2927             : 
    2928         160 :     appendStringInfo(&buf, " LANGUAGE %s\n",
    2929         160 :                      quote_identifier(get_language_name(proc->prolang, false)));
    2930             : 
    2931             :     /* Emit some miscellaneous options on one line */
    2932         160 :     oldlen = buf.len;
    2933             : 
    2934         160 :     if (proc->prokind == PROKIND_WINDOW)
    2935           0 :         appendStringInfoString(&buf, " WINDOW");
    2936         160 :     switch (proc->provolatile)
    2937             :     {
    2938          12 :         case PROVOLATILE_IMMUTABLE:
    2939          12 :             appendStringInfoString(&buf, " IMMUTABLE");
    2940          12 :             break;
    2941          30 :         case PROVOLATILE_STABLE:
    2942          30 :             appendStringInfoString(&buf, " STABLE");
    2943          30 :             break;
    2944         118 :         case PROVOLATILE_VOLATILE:
    2945         118 :             break;
    2946             :     }
    2947             : 
    2948         160 :     switch (proc->proparallel)
    2949             :     {
    2950          28 :         case PROPARALLEL_SAFE:
    2951          28 :             appendStringInfoString(&buf, " PARALLEL SAFE");
    2952          28 :             break;
    2953           0 :         case PROPARALLEL_RESTRICTED:
    2954           0 :             appendStringInfoString(&buf, " PARALLEL RESTRICTED");
    2955           0 :             break;
    2956         132 :         case PROPARALLEL_UNSAFE:
    2957         132 :             break;
    2958             :     }
    2959             : 
    2960         160 :     if (proc->proisstrict)
    2961          50 :         appendStringInfoString(&buf, " STRICT");
    2962         160 :     if (proc->prosecdef)
    2963           6 :         appendStringInfoString(&buf, " SECURITY DEFINER");
    2964         160 :     if (proc->proleakproof)
    2965           0 :         appendStringInfoString(&buf, " LEAKPROOF");
    2966             : 
    2967             :     /* This code for the default cost and rows should match functioncmds.c */
    2968         160 :     if (proc->prolang == INTERNALlanguageId ||
    2969         160 :         proc->prolang == ClanguageId)
    2970          10 :         procost = 1;
    2971             :     else
    2972         150 :         procost = 100;
    2973         160 :     if (proc->procost != procost)
    2974           6 :         appendStringInfo(&buf, " COST %g", proc->procost);
    2975             : 
    2976         160 :     if (proc->prorows > 0 && proc->prorows != 1000)
    2977           0 :         appendStringInfo(&buf, " ROWS %g", proc->prorows);
    2978             : 
    2979         160 :     if (proc->prosupport)
    2980             :     {
    2981             :         Oid         argtypes[1];
    2982             : 
    2983             :         /*
    2984             :          * We should qualify the support function's name if it wouldn't be
    2985             :          * resolved by lookup in the current search path.
    2986             :          */
    2987           0 :         argtypes[0] = INTERNALOID;
    2988           0 :         appendStringInfo(&buf, " SUPPORT %s",
    2989             :                          generate_function_name(proc->prosupport, 1,
    2990             :                                                 NIL, argtypes,
    2991             :                                                 false, NULL, false));
    2992             :     }
    2993             : 
    2994         160 :     if (oldlen != buf.len)
    2995          64 :         appendStringInfoChar(&buf, '\n');
    2996             : 
    2997             :     /* Emit any proconfig options, one per line */
    2998         160 :     tmp = SysCacheGetAttr(PROCOID, proctup, Anum_pg_proc_proconfig, &isnull);
    2999         160 :     if (!isnull)
    3000             :     {
    3001           6 :         ArrayType  *a = DatumGetArrayTypeP(tmp);
    3002             :         int         i;
    3003             : 
    3004             :         Assert(ARR_ELEMTYPE(a) == TEXTOID);
    3005             :         Assert(ARR_NDIM(a) == 1);
    3006             :         Assert(ARR_LBOUND(a)[0] == 1);
    3007             : 
    3008          36 :         for (i = 1; i <= ARR_DIMS(a)[0]; i++)
    3009             :         {
    3010             :             Datum       d;
    3011             : 
    3012          30 :             d = array_ref(a, 1, &i,
    3013             :                           -1 /* varlenarray */ ,
    3014             :                           -1 /* TEXT's typlen */ ,
    3015             :                           false /* TEXT's typbyval */ ,
    3016             :                           TYPALIGN_INT /* TEXT's typalign */ ,
    3017             :                           &isnull);
    3018          30 :             if (!isnull)
    3019             :             {
    3020          30 :                 char       *configitem = TextDatumGetCString(d);
    3021             :                 char       *pos;
    3022             : 
    3023          30 :                 pos = strchr(configitem, '=');
    3024          30 :                 if (pos == NULL)
    3025           0 :                     continue;
    3026          30 :                 *pos++ = '\0';
    3027             : 
    3028          30 :                 appendStringInfo(&buf, " SET %s TO ",
    3029             :                                  quote_identifier(configitem));
    3030             : 
    3031             :                 /*
    3032             :                  * Variables that are marked GUC_LIST_QUOTE were already fully
    3033             :                  * quoted by flatten_set_variable_args() before they were put
    3034             :                  * into the proconfig array.  However, because the quoting
    3035             :                  * rules used there aren't exactly like SQL's, we have to
    3036             :                  * break the list value apart and then quote the elements as
    3037             :                  * string literals.  (The elements may be double-quoted as-is,
    3038             :                  * but we can't just feed them to the SQL parser; it would do
    3039             :                  * the wrong thing with elements that are zero-length or
    3040             :                  * longer than NAMEDATALEN.)
    3041             :                  *
    3042             :                  * Variables that are not so marked should just be emitted as
    3043             :                  * simple string literals.  If the variable is not known to
    3044             :                  * guc.c, we'll do that; this makes it unsafe to use
    3045             :                  * GUC_LIST_QUOTE for extension variables.
    3046             :                  */
    3047          30 :                 if (GetConfigOptionFlags(configitem, true) & GUC_LIST_QUOTE)
    3048             :                 {
    3049             :                     List       *namelist;
    3050             :                     ListCell   *lc;
    3051             : 
    3052             :                     /* Parse string into list of identifiers */
    3053          12 :                     if (!SplitGUCList(pos, ',', &namelist))
    3054             :                     {
    3055             :                         /* this shouldn't fail really */
    3056           0 :                         elog(ERROR, "invalid list syntax in proconfig item");
    3057             :                     }
    3058          42 :                     foreach(lc, namelist)
    3059             :                     {
    3060          30 :                         char       *curname = (char *) lfirst(lc);
    3061             : 
    3062          30 :                         simple_quote_literal(&buf, curname);
    3063          30 :                         if (lnext(namelist, lc))
    3064          18 :                             appendStringInfoString(&buf, ", ");
    3065             :                     }
    3066             :                 }
    3067             :                 else
    3068          18 :                     simple_quote_literal(&buf, pos);
    3069          30 :                 appendStringInfoChar(&buf, '\n');
    3070             :             }
    3071             :         }
    3072             :     }
    3073             : 
    3074             :     /* And finally the function definition ... */
    3075         160 :     (void) SysCacheGetAttr(PROCOID, proctup, Anum_pg_proc_prosqlbody, &isnull);
    3076         160 :     if (proc->prolang == SQLlanguageId && !isnull)
    3077             :     {
    3078         108 :         print_function_sqlbody(&buf, proctup);
    3079             :     }
    3080             :     else
    3081             :     {
    3082          52 :         appendStringInfoString(&buf, "AS ");
    3083             : 
    3084          52 :         tmp = SysCacheGetAttr(PROCOID, proctup, Anum_pg_proc_probin, &isnull);
    3085          52 :         if (!isnull)
    3086             :         {
    3087          10 :             simple_quote_literal(&buf, TextDatumGetCString(tmp));
    3088          10 :             appendStringInfoString(&buf, ", "); /* assume prosrc isn't null */
    3089             :         }
    3090             : 
    3091          52 :         tmp = SysCacheGetAttrNotNull(PROCOID, proctup, Anum_pg_proc_prosrc);
    3092          52 :         prosrc = TextDatumGetCString(tmp);
    3093             : 
    3094             :         /*
    3095             :          * We always use dollar quoting.  Figure out a suitable delimiter.
    3096             :          *
    3097             :          * Since the user is likely to be editing the function body string, we
    3098             :          * shouldn't use a short delimiter that he might easily create a
    3099             :          * conflict with.  Hence prefer "$function$"/"$procedure$", but extend
    3100             :          * if needed.
    3101             :          */
    3102          52 :         initStringInfo(&dq);
    3103          52 :         appendStringInfoChar(&dq, '$');
    3104          52 :         appendStringInfoString(&dq, (isfunction ? "function" : "procedure"));
    3105          52 :         while (strstr(prosrc, dq.data) != NULL)
    3106           0 :             appendStringInfoChar(&dq, 'x');
    3107          52 :         appendStringInfoChar(&dq, '$');
    3108             : 
    3109          52 :         appendBinaryStringInfo(&buf, dq.data, dq.len);
    3110          52 :         appendStringInfoString(&buf, prosrc);
    3111          52 :         appendBinaryStringInfo(&buf, dq.data, dq.len);
    3112             :     }
    3113             : 
    3114         160 :     appendStringInfoChar(&buf, '\n');
    3115             : 
    3116         160 :     ReleaseSysCache(proctup);
    3117             : 
    3118         160 :     PG_RETURN_TEXT_P(string_to_text(buf.data));
    3119             : }
    3120             : 
    3121             : /*
    3122             :  * pg_get_function_arguments
    3123             :  *      Get a nicely-formatted list of arguments for a function.
    3124             :  *      This is everything that would go between the parentheses in
    3125             :  *      CREATE FUNCTION.
    3126             :  */
    3127             : Datum
    3128        4590 : pg_get_function_arguments(PG_FUNCTION_ARGS)
    3129             : {
    3130        4590 :     Oid         funcid = PG_GETARG_OID(0);
    3131             :     StringInfoData buf;
    3132             :     HeapTuple   proctup;
    3133             : 
    3134        4590 :     proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    3135        4590 :     if (!HeapTupleIsValid(proctup))
    3136           6 :         PG_RETURN_NULL();
    3137             : 
    3138        4584 :     initStringInfo(&buf);
    3139             : 
    3140        4584 :     (void) print_function_arguments(&buf, proctup, false, true);
    3141             : 
    3142        4584 :     ReleaseSysCache(proctup);
    3143             : 
    3144        4584 :     PG_RETURN_TEXT_P(string_to_text(buf.data));
    3145             : }
    3146             : 
    3147             : /*
    3148             :  * pg_get_function_identity_arguments
    3149             :  *      Get a formatted list of arguments for a function.
    3150             :  *      This is everything that would go between the parentheses in
    3151             :  *      ALTER FUNCTION, etc.  In particular, don't print defaults.
    3152             :  */
    3153             : Datum
    3154        4070 : pg_get_function_identity_arguments(PG_FUNCTION_ARGS)
    3155             : {
    3156        4070 :     Oid         funcid = PG_GETARG_OID(0);
    3157             :     StringInfoData buf;
    3158             :     HeapTuple   proctup;
    3159             : 
    3160        4070 :     proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    3161        4070 :     if (!HeapTupleIsValid(proctup))
    3162           6 :         PG_RETURN_NULL();
    3163             : 
    3164        4064 :     initStringInfo(&buf);
    3165             : 
    3166        4064 :     (void) print_function_arguments(&buf, proctup, false, false);
    3167             : 
    3168        4064 :     ReleaseSysCache(proctup);
    3169             : 
    3170        4064 :     PG_RETURN_TEXT_P(string_to_text(buf.data));
    3171             : }
    3172             : 
    3173             : /*
    3174             :  * pg_get_function_result
    3175             :  *      Get a nicely-formatted version of the result type of a function.
    3176             :  *      This is what would appear after RETURNS in CREATE FUNCTION.
    3177             :  */
    3178             : Datum
    3179        4004 : pg_get_function_result(PG_FUNCTION_ARGS)
    3180             : {
    3181        4004 :     Oid         funcid = PG_GETARG_OID(0);
    3182             :     StringInfoData buf;
    3183             :     HeapTuple   proctup;
    3184             : 
    3185        4004 :     proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    3186        4004 :     if (!HeapTupleIsValid(proctup))
    3187           6 :         PG_RETURN_NULL();
    3188             : 
    3189        3998 :     if (((Form_pg_proc) GETSTRUCT(proctup))->prokind == PROKIND_PROCEDURE)
    3190             :     {
    3191         240 :         ReleaseSysCache(proctup);
    3192         240 :         PG_RETURN_NULL();
    3193             :     }
    3194             : 
    3195        3758 :     initStringInfo(&buf);
    3196             : 
    3197        3758 :     print_function_rettype(&buf, proctup);
    3198             : 
    3199        3758 :     ReleaseSysCache(proctup);
    3200             : 
    3201        3758 :     PG_RETURN_TEXT_P(string_to_text(buf.data));
    3202             : }
    3203             : 
    3204             : /*
    3205             :  * Guts of pg_get_function_result: append the function's return type
    3206             :  * to the specified buffer.
    3207             :  */
    3208             : static void
    3209        3898 : print_function_rettype(StringInfo buf, HeapTuple proctup)
    3210             : {
    3211        3898 :     Form_pg_proc proc = (Form_pg_proc) GETSTRUCT(proctup);
    3212        3898 :     int         ntabargs = 0;
    3213             :     StringInfoData rbuf;
    3214             : 
    3215        3898 :     initStringInfo(&rbuf);
    3216             : 
    3217        3898 :     if (proc->proretset)
    3218             :     {
    3219             :         /* It might be a table function; try to print the arguments */
    3220         406 :         appendStringInfoString(&rbuf, "TABLE(");
    3221         406 :         ntabargs = print_function_arguments(&rbuf, proctup, true, false);
    3222         406 :         if (ntabargs > 0)
    3223          76 :             appendStringInfoChar(&rbuf, ')');
    3224             :         else
    3225         330 :             resetStringInfo(&rbuf);
    3226             :     }
    3227             : 
    3228        3898 :     if (ntabargs == 0)
    3229             :     {
    3230             :         /* Not a table function, so do the normal thing */
    3231        3822 :         if (proc->proretset)
    3232         330 :             appendStringInfoString(&rbuf, "SETOF ");
    3233        3822 :         appendStringInfoString(&rbuf, format_type_be(proc->prorettype));
    3234             :     }
    3235             : 
    3236        3898 :     appendBinaryStringInfo(buf, rbuf.data, rbuf.len);
    3237        3898 : }
    3238             : 
    3239             : /*
    3240             :  * Common code for pg_get_function_arguments and pg_get_function_result:
    3241             :  * append the desired subset of arguments to buf.  We print only TABLE
    3242             :  * arguments when print_table_args is true, and all the others when it's false.
    3243             :  * We print argument defaults only if print_defaults is true.
    3244             :  * Function return value is the number of arguments printed.
    3245             :  */
    3246             : static int
    3247        9214 : print_function_arguments(StringInfo buf, HeapTuple proctup,
    3248             :                          bool print_table_args, bool print_defaults)
    3249             : {
    3250        9214 :     Form_pg_proc proc = (Form_pg_proc) GETSTRUCT(proctup);
    3251             :     int         numargs;
    3252             :     Oid        *argtypes;
    3253             :     char      **argnames;
    3254             :     char       *argmodes;
    3255        9214 :     int         insertorderbyat = -1;
    3256             :     int         argsprinted;
    3257             :     int         inputargno;
    3258             :     int         nlackdefaults;
    3259        9214 :     List       *argdefaults = NIL;
    3260        9214 :     ListCell   *nextargdefault = NULL;
    3261             :     int         i;
    3262             : 
    3263        9214 :     numargs = get_func_arg_info(proctup,
    3264             :                                 &argtypes, &argnames, &argmodes);
    3265             : 
    3266        9214 :     nlackdefaults = numargs;
    3267        9214 :     if (print_defaults && proc->pronargdefaults > 0)
    3268             :     {
    3269             :         Datum       proargdefaults;
    3270             :         bool        isnull;
    3271             : 
    3272          38 :         proargdefaults = SysCacheGetAttr(PROCOID, proctup,
    3273             :                                          Anum_pg_proc_proargdefaults,
    3274             :                                          &isnull);
    3275          38 :         if (!isnull)
    3276             :         {
    3277             :             char       *str;
    3278             : 
    3279          38 :             str = TextDatumGetCString(proargdefaults);
    3280          38 :             argdefaults = castNode(List, stringToNode(str));
    3281          38 :             pfree(str);
    3282          38 :             nextargdefault = list_head(argdefaults);
    3283             :             /* nlackdefaults counts only *input* arguments lacking defaults */
    3284          38 :             nlackdefaults = proc->pronargs - list_length(argdefaults);
    3285             :         }
    3286             :     }
    3287             : 
    3288             :     /* Check for special treatment of ordered-set aggregates */
    3289        9214 :     if (proc->prokind == PROKIND_AGGREGATE)
    3290             :     {
    3291             :         HeapTuple   aggtup;
    3292             :         Form_pg_aggregate agg;
    3293             : 
    3294        1174 :         aggtup = SearchSysCache1(AGGFNOID, ObjectIdGetDatum(proc->oid));
    3295        1174 :         if (!HeapTupleIsValid(aggtup))
    3296           0 :             elog(ERROR, "cache lookup failed for aggregate %u",
    3297             :                  proc->oid);
    3298        1174 :         agg = (Form_pg_aggregate) GETSTRUCT(aggtup);
    3299        1174 :         if (AGGKIND_IS_ORDERED_SET(agg->aggkind))
    3300          52 :             insertorderbyat = agg->aggnumdirectargs;
    3301        1174 :         ReleaseSysCache(aggtup);
    3302             :     }
    3303             : 
    3304        9214 :     argsprinted = 0;
    3305        9214 :     inputargno = 0;
    3306       18560 :     for (i = 0; i < numargs; i++)
    3307             :     {
    3308        9346 :         Oid         argtype = argtypes[i];
    3309        9346 :         char       *argname = argnames ? argnames[i] : NULL;
    3310        9346 :         char        argmode = argmodes ? argmodes[i] : PROARGMODE_IN;
    3311             :         const char *modename;
    3312             :         bool        isinput;
    3313             : 
    3314        9346 :         switch (argmode)
    3315             :         {
    3316        7740 :             case PROARGMODE_IN:
    3317             : 
    3318             :                 /*
    3319             :                  * For procedures, explicitly mark all argument modes, so as
    3320             :                  * to avoid ambiguity with the SQL syntax for DROP PROCEDURE.
    3321             :                  */
    3322        7740 :                 if (proc->prokind == PROKIND_PROCEDURE)
    3323         536 :                     modename = "IN ";
    3324             :                 else
    3325        7204 :                     modename = "";
    3326        7740 :                 isinput = true;
    3327        7740 :                 break;
    3328         100 :             case PROARGMODE_INOUT:
    3329         100 :                 modename = "INOUT ";
    3330         100 :                 isinput = true;
    3331         100 :                 break;
    3332         956 :             case PROARGMODE_OUT:
    3333         956 :                 modename = "OUT ";
    3334         956 :                 isinput = false;
    3335         956 :                 break;
    3336         178 :             case PROARGMODE_VARIADIC:
    3337         178 :                 modename = "VARIADIC ";
    3338         178 :                 isinput = true;
    3339         178 :                 break;
    3340         372 :             case PROARGMODE_TABLE:
    3341         372 :                 modename = "";
    3342         372 :                 isinput = false;
    3343         372 :                 break;
    3344           0 :             default:
    3345           0 :                 elog(ERROR, "invalid parameter mode '%c'", argmode);
    3346             :                 modename = NULL;    /* keep compiler quiet */
    3347             :                 isinput = false;
    3348             :                 break;
    3349             :         }
    3350        9346 :         if (isinput)
    3351        8018 :             inputargno++;       /* this is a 1-based counter */
    3352             : 
    3353        9346 :         if (print_table_args != (argmode == PROARGMODE_TABLE))
    3354         728 :             continue;
    3355             : 
    3356        8618 :         if (argsprinted == insertorderbyat)
    3357             :         {
    3358          52 :             if (argsprinted)
    3359          52 :                 appendStringInfoChar(buf, ' ');
    3360          52 :             appendStringInfoString(buf, "ORDER BY ");
    3361             :         }
    3362        8566 :         else if (argsprinted)
    3363        2740 :             appendStringInfoString(buf, ", ");
    3364             : 
    3365        8618 :         appendStringInfoString(buf, modename);
    3366        8618 :         if (argname && argname[0])
    3367        3074 :             appendStringInfo(buf, "%s ", quote_identifier(argname));
    3368        8618 :         appendStringInfoString(buf, format_type_be(argtype));
    3369        8618 :         if (print_defaults && isinput && inputargno > nlackdefaults)
    3370             :         {
    3371             :             Node       *expr;
    3372             : 
    3373             :             Assert(nextargdefault != NULL);
    3374          58 :             expr = (Node *) lfirst(nextargdefault);
    3375          58 :             nextargdefault = lnext(argdefaults, nextargdefault);
    3376             : 
    3377          58 :             appendStringInfo(buf, " DEFAULT %s",
    3378             :                              deparse_expression(expr, NIL, false, false));
    3379             :         }
    3380        8618 :         argsprinted++;
    3381             : 
    3382             :         /* nasty hack: print the last arg twice for variadic ordered-set agg */
    3383        8618 :         if (argsprinted == insertorderbyat && i == numargs - 1)
    3384             :         {
    3385          26 :             i--;
    3386             :             /* aggs shouldn't have defaults anyway, but just to be sure ... */
    3387          26 :             print_defaults = false;
    3388             :         }
    3389             :     }
    3390             : 
    3391        9214 :     return argsprinted;
    3392             : }
    3393             : 
    3394             : static bool
    3395          96 : is_input_argument(int nth, const char *argmodes)
    3396             : {
    3397             :     return (!argmodes
    3398          42 :             || argmodes[nth] == PROARGMODE_IN
    3399          18 :             || argmodes[nth] == PROARGMODE_INOUT
    3400         138 :             || argmodes[nth] == PROARGMODE_VARIADIC);
    3401             : }
    3402             : 
    3403             : /*
    3404             :  * Append used transformed types to specified buffer
    3405             :  */
    3406             : static void
    3407         160 : print_function_trftypes(StringInfo buf, HeapTuple proctup)
    3408             : {
    3409             :     Oid        *trftypes;
    3410             :     int         ntypes;
    3411             : 
    3412         160 :     ntypes = get_func_trftypes(proctup, &trftypes);
    3413         160 :     if (ntypes > 0)
    3414             :     {
    3415             :         int         i;
    3416             : 
    3417           6 :         appendStringInfoString(buf, " TRANSFORM ");
    3418          16 :         for (i = 0; i < ntypes; i++)
    3419             :         {
    3420          10 :             if (i != 0)
    3421           4 :                 appendStringInfoString(buf, ", ");
    3422          10 :             appendStringInfo(buf, "FOR TYPE %s", format_type_be(trftypes[i]));
    3423             :         }
    3424           6 :         appendStringInfoChar(buf, '\n');
    3425             :     }
    3426         160 : }
    3427             : 
    3428             : /*
    3429             :  * Get textual representation of a function argument's default value.  The
    3430             :  * second argument of this function is the argument number among all arguments
    3431             :  * (i.e. proallargtypes, *not* proargtypes), starting with 1, because that's
    3432             :  * how information_schema.sql uses it.
    3433             :  */
    3434             : Datum
    3435          54 : pg_get_function_arg_default(PG_FUNCTION_ARGS)
    3436             : {
    3437          54 :     Oid         funcid = PG_GETARG_OID(0);
    3438          54 :     int32       nth_arg = PG_GETARG_INT32(1);
    3439             :     HeapTuple   proctup;
    3440             :     Form_pg_proc proc;
    3441             :     int         numargs;
    3442             :     Oid        *argtypes;
    3443             :     char      **argnames;
    3444             :     char       *argmodes;
    3445             :     int         i;
    3446             :     List       *argdefaults;
    3447             :     Node       *node;
    3448             :     char       *str;
    3449             :     int         nth_inputarg;
    3450             :     Datum       proargdefaults;
    3451             :     bool        isnull;
    3452             :     int         nth_default;
    3453             : 
    3454          54 :     proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    3455          54 :     if (!HeapTupleIsValid(proctup))
    3456          12 :         PG_RETURN_NULL();
    3457             : 
    3458          42 :     numargs = get_func_arg_info(proctup, &argtypes, &argnames, &argmodes);
    3459          42 :     if (nth_arg < 1 || nth_arg > numargs || !is_input_argument(nth_arg - 1, argmodes))
    3460             :     {
    3461          12 :         ReleaseSysCache(proctup);
    3462          12 :         PG_RETURN_NULL();
    3463             :     }
    3464             : 
    3465          30 :     nth_inputarg = 0;
    3466          84 :     for (i = 0; i < nth_arg; i++)
    3467          54 :         if (is_input_argument(i, argmodes))
    3468          48 :             nth_inputarg++;
    3469             : 
    3470          30 :     proargdefaults = SysCacheGetAttr(PROCOID, proctup,
    3471             :                                      Anum_pg_proc_proargdefaults,
    3472             :                                      &isnull);
    3473          30 :     if (isnull)
    3474             :     {
    3475           0 :         ReleaseSysCache(proctup);
    3476           0 :         PG_RETURN_NULL();
    3477             :     }
    3478             : 
    3479          30 :     str = TextDatumGetCString(proargdefaults);
    3480          30 :     argdefaults = castNode(List, stringToNode(str));
    3481          30 :     pfree(str);
    3482             : 
    3483          30 :     proc = (Form_pg_proc) GETSTRUCT(proctup);
    3484             : 
    3485             :     /*
    3486             :      * Calculate index into proargdefaults: proargdefaults corresponds to the
    3487             :      * last N input arguments, where N = pronargdefaults.
    3488             :      */
    3489          30 :     nth_default = nth_inputarg - 1 - (proc->pronargs - proc->pronargdefaults);
    3490             : 
    3491          30 :     if (nth_default < 0 || nth_default >= list_length(argdefaults))
    3492             :     {
    3493           6 :         ReleaseSysCache(proctup);
    3494           6 :         PG_RETURN_NULL();
    3495             :     }
    3496          24 :     node = list_nth(argdefaults, nth_default);
    3497          24 :     str = deparse_expression(node, NIL, false, false);
    3498             : 
    3499          24 :     ReleaseSysCache(proctup);
    3500             : 
    3501          24 :     PG_RETURN_TEXT_P(string_to_text(str));
    3502             : }
    3503             : 
    3504             : static void
    3505         206 : print_function_sqlbody(StringInfo buf, HeapTuple proctup)
    3506             : {
    3507             :     int         numargs;
    3508             :     Oid        *argtypes;
    3509             :     char      **argnames;
    3510             :     char       *argmodes;
    3511         206 :     deparse_namespace dpns = {0};
    3512             :     Datum       tmp;
    3513             :     Node       *n;
    3514             : 
    3515         206 :     dpns.funcname = pstrdup(NameStr(((Form_pg_proc) GETSTRUCT(proctup))->proname));
    3516         206 :     numargs = get_func_arg_info(proctup,
    3517             :                                 &argtypes, &argnames, &argmodes);
    3518         206 :     dpns.numargs = numargs;
    3519         206 :     dpns.argnames = argnames;
    3520             : 
    3521         206 :     tmp = SysCacheGetAttrNotNull(PROCOID, proctup, Anum_pg_proc_prosqlbody);
    3522         206 :     n = stringToNode(TextDatumGetCString(tmp));
    3523             : 
    3524         206 :     if (IsA(n, List))
    3525             :     {
    3526             :         List       *stmts;
    3527             :         ListCell   *lc;
    3528             : 
    3529         160 :         stmts = linitial(castNode(List, n));
    3530             : 
    3531         160 :         appendStringInfoString(buf, "BEGIN ATOMIC\n");
    3532             : 
    3533         310 :         foreach(lc, stmts)
    3534             :         {
    3535         150 :             Query      *query = lfirst_node(Query, lc);
    3536             : 
    3537             :             /* It seems advisable to get at least AccessShareLock on rels */
    3538         150 :             AcquireRewriteLocks(query, false, false);
    3539         150 :             get_query_def(query, buf, list_make1(&dpns), NULL, false,
    3540             :                           PRETTYFLAG_INDENT, WRAP_COLUMN_DEFAULT, 1);
    3541         150 :             appendStringInfoChar(buf, ';');
    3542         150 :             appendStringInfoChar(buf, '\n');
    3543             :         }
    3544             : 
    3545         160 :         appendStringInfoString(buf, "END");
    3546             :     }
    3547             :     else
    3548             :     {
    3549          46 :         Query      *query = castNode(Query, n);
    3550             : 
    3551             :         /* It seems advisable to get at least AccessShareLock on rels */
    3552          46 :         AcquireRewriteLocks(query, false, false);
    3553          46 :         get_query_def(query, buf, list_make1(&dpns), NULL, false,
    3554             :                       0, WRAP_COLUMN_DEFAULT, 0);
    3555             :     }
    3556         206 : }
    3557             : 
    3558             : Datum
    3559        3492 : pg_get_function_sqlbody(PG_FUNCTION_ARGS)
    3560             : {
    3561        3492 :     Oid         funcid = PG_GETARG_OID(0);
    3562             :     StringInfoData buf;
    3563             :     HeapTuple   proctup;
    3564             :     bool        isnull;
    3565             : 
    3566        3492 :     initStringInfo(&buf);
    3567             : 
    3568             :     /* Look up the function */
    3569        3492 :     proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    3570        3492 :     if (!HeapTupleIsValid(proctup))
    3571           0 :         PG_RETURN_NULL();
    3572             : 
    3573        3492 :     (void) SysCacheGetAttr(PROCOID, proctup, Anum_pg_proc_prosqlbody, &isnull);
    3574        3492 :     if (isnull)
    3575             :     {
    3576        3394 :         ReleaseSysCache(proctup);
    3577        3394 :         PG_RETURN_NULL();
    3578             :     }
    3579             : 
    3580          98 :     print_function_sqlbody(&buf, proctup);
    3581             : 
    3582          98 :     ReleaseSysCache(proctup);
    3583             : 
    3584          98 :     PG_RETURN_TEXT_P(cstring_to_text_with_len(buf.data, buf.len));
    3585             : }
    3586             : 
    3587             : 
    3588             : /*
    3589             :  * deparse_expression           - General utility for deparsing expressions
    3590             :  *
    3591             :  * calls deparse_expression_pretty with all prettyPrinting disabled
    3592             :  */
    3593             : char *
    3594       62598 : deparse_expression(Node *expr, List *dpcontext,
    3595             :                    bool forceprefix, bool showimplicit)
    3596             : {
    3597       62598 :     return deparse_expression_pretty(expr, dpcontext, forceprefix,
    3598             :                                      showimplicit, 0, 0);
    3599             : }
    3600             : 
    3601             : /* ----------
    3602             :  * deparse_expression_pretty    - General utility for deparsing expressions
    3603             :  *
    3604             :  * expr is the node tree to be deparsed.  It must be a transformed expression
    3605             :  * tree (ie, not the raw output of gram.y).
    3606             :  *
    3607             :  * dpcontext is a list of deparse_namespace nodes representing the context
    3608             :  * for interpreting Vars in the node tree.  It can be NIL if no Vars are
    3609             :  * expected.
    3610             :  *
    3611             :  * forceprefix is true to force all Vars to be prefixed with their table names.
    3612             :  *
    3613             :  * showimplicit is true to force all implicit casts to be shown explicitly.
    3614             :  *
    3615             :  * Tries to pretty up the output according to prettyFlags and startIndent.
    3616             :  *
    3617             :  * The result is a palloc'd string.
    3618             :  * ----------
    3619             :  */
    3620             : static char *
    3621       73624 : deparse_expression_pretty(Node *expr, List *dpcontext,
    3622             :                           bool forceprefix, bool showimplicit,
    3623             :                           int prettyFlags, int startIndent)
    3624             : {
    3625             :     StringInfoData buf;
    3626             :     deparse_context context;
    3627             : 
    3628       73624 :     initStringInfo(&buf);
    3629       73624 :     context.buf = &buf;
    3630       73624 :     context.namespaces = dpcontext;
    3631       73624 :     context.resultDesc = NULL;
    3632       73624 :     context.targetList = NIL;
    3633       73624 :     context.windowClause = NIL;
    3634       73624 :     context.varprefix = forceprefix;
    3635       73624 :     context.prettyFlags = prettyFlags;
    3636       73624 :     context.wrapColumn = WRAP_COLUMN_DEFAULT;
    3637       73624 :     context.indentLevel = startIndent;
    3638       73624 :     context.colNamesVisible = true;
    3639       73624 :     context.inGroupBy = false;
    3640       73624 :     context.varInOrderBy = false;
    3641       73624 :     context.appendparents = NULL;
    3642             : 
    3643       73624 :     get_rule_expr(expr, &context, showimplicit);
    3644             : 
    3645       73624 :     return buf.data;
    3646             : }
    3647             : 
    3648             : /* ----------
    3649             :  * deparse_context_for          - Build deparse context for a single relation
    3650             :  *
    3651             :  * Given the reference name (alias) and OID of a relation, build deparsing
    3652             :  * context for an expression referencing only that relation (as varno 1,
    3653             :  * varlevelsup 0).  This is sufficient for many uses of deparse_expression.
    3654             :  * ----------
    3655             :  */
    3656             : List *
    3657       20164 : deparse_context_for(const char *aliasname, Oid relid)
    3658             : {
    3659             :     deparse_namespace *dpns;
    3660             :     RangeTblEntry *rte;
    3661             : 
    3662       20164 :     dpns = (deparse_namespace *) palloc0(sizeof(deparse_namespace));
    3663             : 
    3664             :     /* Build a minimal RTE for the rel */
    3665       20164 :     rte = makeNode(RangeTblEntry);
    3666       20164 :     rte->rtekind = RTE_RELATION;
    3667       20164 :     rte->relid = relid;
    3668       20164 :     rte->relkind = RELKIND_RELATION; /* no need for exactness here */
    3669       20164 :     rte->rellockmode = AccessShareLock;
    3670       20164 :     rte->alias = makeAlias(aliasname, NIL);
    3671       20164 :     rte->eref = rte->alias;
    3672       20164 :     rte->lateral = false;
    3673       20164 :     rte->inh = false;
    3674       20164 :     rte->inFromCl = true;
    3675             : 
    3676             :     /* Build one-element rtable */
    3677       20164 :     dpns->rtable = list_make1(rte);
    3678       20164 :     dpns->subplans = NIL;
    3679       20164 :     dpns->ctes = NIL;
    3680       20164 :     dpns->appendrels = NULL;
    3681       20164 :     set_rtable_names(dpns, NIL, NULL);
    3682       20164 :     set_simple_column_names(dpns);
    3683             : 
    3684             :     /* Return a one-deep namespace stack */
    3685       20164 :     return list_make1(dpns);
    3686             : }
    3687             : 
    3688             : /*
    3689             :  * deparse_context_for_plan_tree - Build deparse context for a Plan tree
    3690             :  *
    3691             :  * When deparsing an expression in a Plan tree, we use the plan's rangetable
    3692             :  * to resolve names of simple Vars.  The initialization of column names for
    3693             :  * this is rather expensive if the rangetable is large, and it'll be the same
    3694             :  * for every expression in the Plan tree; so we do it just once and re-use
    3695             :  * the result of this function for each expression.  (Note that the result
    3696             :  * is not usable until set_deparse_context_plan() is applied to it.)
    3697             :  *
    3698             :  * In addition to the PlannedStmt, pass the per-RTE alias names
    3699             :  * assigned by a previous call to select_rtable_names_for_explain.
    3700             :  */
    3701             : List *
    3702       21806 : deparse_context_for_plan_tree(PlannedStmt *pstmt, List *rtable_names)
    3703             : {
    3704             :     deparse_namespace *dpns;
    3705             : 
    3706       21806 :     dpns = (deparse_namespace *) palloc0(sizeof(deparse_namespace));
    3707             : 
    3708             :     /* Initialize fields that stay the same across the whole plan tree */
    3709       21806 :     dpns->rtable = pstmt->rtable;
    3710       21806 :     dpns->rtable_names = rtable_names;
    3711       21806 :     dpns->subplans = pstmt->subplans;
    3712       21806 :     dpns->ctes = NIL;
    3713       21806 :     if (pstmt->appendRelations)
    3714             :     {
    3715             :         /* Set up the array, indexed by child relid */
    3716        3582 :         int         ntables = list_length(dpns->rtable);
    3717             :         ListCell   *lc;
    3718             : 
    3719        3582 :         dpns->appendrels = (AppendRelInfo **)
    3720        3582 :             palloc0((ntables + 1) * sizeof(AppendRelInfo *));
    3721       19744 :         foreach(lc, pstmt->appendRelations)
    3722             :         {
    3723       16162 :             AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
    3724       16162 :             Index       crelid = appinfo->child_relid;
    3725             : 
    3726             :             Assert(crelid > 0 && crelid <= ntables);
    3727             :             Assert(dpns->appendrels[crelid] == NULL);
    3728       16162 :             dpns->appendrels[crelid] = appinfo;
    3729             :         }
    3730             :     }
    3731             :     else
    3732       18224 :         dpns->appendrels = NULL; /* don't need it */
    3733             : 
    3734             :     /*
    3735             :      * Set up column name aliases.  We will get rather bogus results for join
    3736             :      * RTEs, but that doesn't matter because plan trees don't contain any join
    3737             :      * alias Vars.
    3738             :      */
    3739       21806 :     set_simple_column_names(dpns);
    3740             : 
    3741             :     /* Return a one-deep namespace stack */
    3742       21806 :     return list_make1(dpns);
    3743             : }
    3744             : 
    3745             : /*
    3746             :  * set_deparse_context_plan - Specify Plan node containing expression
    3747             :  *
    3748             :  * When deparsing an expression in a Plan tree, we might have to resolve
    3749             :  * OUTER_VAR, INNER_VAR, or INDEX_VAR references.  To do this, the caller must
    3750             :  * provide the parent Plan node.  Then OUTER_VAR and INNER_VAR references
    3751             :  * can be resolved by drilling down into the left and right child plans.
    3752             :  * Similarly, INDEX_VAR references can be resolved by reference to the
    3753             :  * indextlist given in a parent IndexOnlyScan node, or to the scan tlist in
    3754             :  * ForeignScan and CustomScan nodes.  (Note that we don't currently support
    3755             :  * deparsing of indexquals in regular IndexScan or BitmapIndexScan nodes;
    3756             :  * for those, we can only deparse the indexqualorig fields, which won't
    3757             :  * contain INDEX_VAR Vars.)
    3758             :  *
    3759             :  * The ancestors list is a list of the Plan's parent Plan and SubPlan nodes,
    3760             :  * the most-closely-nested first.  This is needed to resolve PARAM_EXEC
    3761             :  * Params.  Note we assume that all the Plan nodes share the same rtable.
    3762             :  *
    3763             :  * Once this function has been called, deparse_expression() can be called on
    3764             :  * subsidiary expression(s) of the specified Plan node.  To deparse
    3765             :  * expressions of a different Plan node in the same Plan tree, re-call this
    3766             :  * function to identify the new parent Plan node.
    3767             :  *
    3768             :  * The result is the same List passed in; this is a notational convenience.
    3769             :  */
    3770             : List *
    3771       47304 : set_deparse_context_plan(List *dpcontext, Plan *plan, List *ancestors)
    3772             : {
    3773             :     deparse_namespace *dpns;
    3774             : 
    3775             :     /* Should always have one-entry namespace list for Plan deparsing */
    3776             :     Assert(list_length(dpcontext) == 1);
    3777       47304 :     dpns = (deparse_namespace *) linitial(dpcontext);
    3778             : 
    3779             :     /* Set our attention on the specific plan node passed in */
    3780       47304 :     dpns->ancestors = ancestors;
    3781       47304 :     set_deparse_plan(dpns, plan);
    3782             : 
    3783       47304 :     return dpcontext;
    3784             : }
    3785             : 
    3786             : /*
    3787             :  * select_rtable_names_for_explain  - Select RTE aliases for EXPLAIN
    3788             :  *
    3789             :  * Determine the relation aliases we'll use during an EXPLAIN operation.
    3790             :  * This is just a frontend to set_rtable_names.  We have to expose the aliases
    3791             :  * to EXPLAIN because EXPLAIN needs to know the right alias names to print.
    3792             :  */
    3793             : List *
    3794       21806 : select_rtable_names_for_explain(List *rtable, Bitmapset *rels_used)
    3795             : {
    3796             :     deparse_namespace dpns;
    3797             : 
    3798       21806 :     memset(&dpns, 0, sizeof(dpns));
    3799       21806 :     dpns.rtable = rtable;
    3800       21806 :     dpns.subplans = NIL;
    3801       21806 :     dpns.ctes = NIL;
    3802       21806 :     dpns.appendrels = NULL;
    3803       21806 :     set_rtable_names(&dpns, NIL, rels_used);
    3804             :     /* We needn't bother computing column aliases yet */
    3805             : 
    3806       21806 :     return dpns.rtable_names;
    3807             : }
    3808             : 
    3809             : /*
    3810             :  * set_rtable_names: select RTE aliases to be used in printing a query
    3811             :  *
    3812             :  * We fill in dpns->rtable_names with a list of names that is one-for-one with
    3813             :  * the already-filled dpns->rtable list.  Each RTE name is unique among those
    3814             :  * in the new namespace plus any ancestor namespaces listed in
    3815             :  * parent_namespaces.
    3816             :  *
    3817             :  * If rels_used isn't NULL, only RTE indexes listed in it are given aliases.
    3818             :  *
    3819             :  * Note that this function is only concerned with relation names, not column
    3820             :  * names.
    3821             :  */
    3822             : static void
    3823       47766 : set_rtable_names(deparse_namespace *dpns, List *parent_namespaces,
    3824             :                  Bitmapset *rels_used)
    3825             : {
    3826             :     HASHCTL     hash_ctl;
    3827             :     HTAB       *names_hash;
    3828             :     NameHashEntry *hentry;
    3829             :     bool        found;
    3830             :     int         rtindex;
    3831             :     ListCell   *lc;
    3832             : 
    3833       47766 :     dpns->rtable_names = NIL;
    3834             :     /* nothing more to do if empty rtable */
    3835       47766 :     if (dpns->rtable == NIL)
    3836         518 :         return;
    3837             : 
    3838             :     /*
    3839             :      * We use a hash table to hold known names, so that this process is O(N)
    3840             :      * not O(N^2) for N names.
    3841             :      */
    3842       47248 :     hash_ctl.keysize = NAMEDATALEN;
    3843       47248 :     hash_ctl.entrysize = sizeof(NameHashEntry);
    3844       47248 :     hash_ctl.hcxt = CurrentMemoryContext;
    3845       47248 :     names_hash = hash_create("set_rtable_names names",
    3846       47248 :                              list_length(dpns->rtable),
    3847             :                              &hash_ctl,
    3848             :                              HASH_ELEM | HASH_STRINGS | HASH_CONTEXT);
    3849             : 
    3850             :     /* Preload the hash table with names appearing in parent_namespaces */
    3851       48848 :     foreach(lc, parent_namespaces)
    3852             :     {
    3853        1600 :         deparse_namespace *olddpns = (deparse_namespace *) lfirst(lc);
    3854             :         ListCell   *lc2;
    3855             : 
    3856        6036 :         foreach(lc2, olddpns->rtable_names)
    3857             :         {
    3858        4436 :             char       *oldname = (char *) lfirst(lc2);
    3859             : 
    3860        4436 :             if (oldname == NULL)
    3861         336 :                 continue;
    3862        4100 :             hentry = (NameHashEntry *) hash_search(names_hash,
    3863             :                                                    oldname,
    3864             :                                                    HASH_ENTER,
    3865             :                                                    &found);
    3866             :             /* we do not complain about duplicate names in parent namespaces */
    3867        4100 :             hentry->counter = 0;
    3868             :         }
    3869             :     }
    3870             : 
    3871             :     /* Now we can scan the rtable */
    3872       47248 :     rtindex = 1;
    3873      134542 :     foreach(lc, dpns->rtable)
    3874             :     {
    3875       87294 :         RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
    3876             :         char       *refname;
    3877             : 
    3878             :         /* Just in case this takes an unreasonable amount of time ... */
    3879       87294 :         CHECK_FOR_INTERRUPTS();
    3880             : 
    3881       87294 :         if (rels_used && !bms_is_member(rtindex, rels_used))
    3882             :         {
    3883             :             /* Ignore unreferenced RTE */
    3884       13682 :             refname = NULL;
    3885             :         }
    3886       73612 :         else if (rte->alias)
    3887             :         {
    3888             :             /* If RTE has a user-defined alias, prefer that */
    3889       48774 :             refname = rte->alias->aliasname;
    3890             :         }
    3891       24838 :         else if (rte->rtekind == RTE_RELATION)
    3892             :         {
    3893             :             /* Use the current actual name of the relation */
    3894       20686 :             refname = get_rel_name(rte->relid);
    3895             :         }
    3896        4152 :         else if (rte->rtekind == RTE_JOIN)
    3897             :         {
    3898             :             /* Unnamed join has no refname */
    3899        1818 :             refname = NULL;
    3900             :         }
    3901             :         else
    3902             :         {
    3903             :             /* Otherwise use whatever the parser assigned */
    3904        2334 :             refname = rte->eref->aliasname;
    3905             :         }
    3906             : 
    3907             :         /*
    3908             :          * If the selected name isn't unique, append digits to make it so, and
    3909             :          * make a new hash entry for it once we've got a unique name.  For a
    3910             :          * very long input name, we might have to truncate to stay within
    3911             :          * NAMEDATALEN.
    3912             :          */
    3913       87294 :         if (refname)
    3914             :         {
    3915       71794 :             hentry = (NameHashEntry *) hash_search(names_hash,
    3916             :                                                    refname,
    3917             :                                                    HASH_ENTER,
    3918             :                                                    &found);
    3919       71794 :             if (found)
    3920             :             {
    3921             :                 /* Name already in use, must choose a new one */
    3922       13166 :                 int         refnamelen = strlen(refname);
    3923       13166 :                 char       *modname = (char *) palloc(refnamelen + 16);
    3924             :                 NameHashEntry *hentry2;
    3925             : 
    3926             :                 do
    3927             :                 {
    3928       13172 :                     hentry->counter++;
    3929             :                     for (;;)
    3930             :                     {
    3931       13184 :                         memcpy(modname, refname, refnamelen);
    3932       13184 :                         sprintf(modname + refnamelen, "_%d", hentry->counter);
    3933       13184 :                         if (strlen(modname) < NAMEDATALEN)
    3934       13172 :                             break;
    3935             :                         /* drop chars from refname to keep all the digits */
    3936          12 :                         refnamelen = pg_mbcliplen(refname, refnamelen,
    3937             :                                                   refnamelen - 1);
    3938             :                     }
    3939       13172 :                     hentry2 = (NameHashEntry *) hash_search(names_hash,
    3940             :                                                             modname,
    3941             :                                                             HASH_ENTER,
    3942             :                                                             &found);
    3943       13172 :                 } while (found);
    3944       13166 :                 hentry2->counter = 0;    /* init new hash entry */
    3945       13166 :                 refname = modname;
    3946             :             }
    3947             :             else
    3948             :             {
    3949             :                 /* Name not previously used, need only initialize hentry */
    3950       58628 :                 hentry->counter = 0;
    3951             :             }
    3952             :         }
    3953             : 
    3954       87294 :         dpns->rtable_names = lappend(dpns->rtable_names, refname);
    3955       87294 :         rtindex++;
    3956             :     }
    3957             : 
    3958       47248 :     hash_destroy(names_hash);
    3959             : }
    3960             : 
    3961             : /*
    3962             :  * set_deparse_for_query: set up deparse_namespace for deparsing a Query tree
    3963             :  *
    3964             :  * For convenience, this is defined to initialize the deparse_namespace struct
    3965             :  * from scratch.
    3966             :  */
    3967             : static void
    3968        5658 : set_deparse_for_query(deparse_namespace *dpns, Query *query,
    3969             :                       List *parent_namespaces)
    3970             : {
    3971             :     ListCell   *lc;
    3972             :     ListCell   *lc2;
    3973             : 
    3974             :     /* Initialize *dpns and fill rtable/ctes links */
    3975        5658 :     memset(dpns, 0, sizeof(deparse_namespace));
    3976        5658 :     dpns->rtable = query->rtable;
    3977        5658 :     dpns->subplans = NIL;
    3978        5658 :     dpns->ctes = query->cteList;
    3979        5658 :     dpns->appendrels = NULL;
    3980             : 
    3981             :     /* Assign a unique relation alias to each RTE */
    3982        5658 :     set_rtable_names(dpns, parent_namespaces, NULL);
    3983             : 
    3984             :     /* Initialize dpns->rtable_columns to contain zeroed structs */
    3985        5658 :     dpns->rtable_columns = NIL;
    3986       15784 :     while (list_length(dpns->rtable_columns) < list_length(dpns->rtable))
    3987       10126 :         dpns->rtable_columns = lappend(dpns->rtable_columns,
    3988             :                                        palloc0(sizeof(deparse_columns)));
    3989             : 
    3990             :     /* If it's a utility query, it won't have a jointree */
    3991        5658 :     if (query->jointree)
    3992             :     {
    3993             :         /* Detect whether global uniqueness of USING names is needed */
    3994        5642 :         dpns->unique_using =
    3995        5642 :             has_dangerous_join_using(dpns, (Node *) query->jointree);
    3996             : 
    3997             :         /*
    3998             :          * Select names for columns merged by USING, via a recursive pass over
    3999             :          * the query jointree.
    4000             :          */
    4001        5642 :         set_using_names(dpns, (Node *) query->jointree, NIL);
    4002             :     }
    4003             : 
    4004             :     /*
    4005             :      * Now assign remaining column aliases for each RTE.  We do this in a
    4006             :      * linear scan of the rtable, so as to process RTEs whether or not they
    4007             :      * are in the jointree (we mustn't miss NEW.*, INSERT target relations,
    4008             :      * etc).  JOIN RTEs must be processed after their children, but this is
    4009             :      * okay because they appear later in the rtable list than their children
    4010             :      * (cf Asserts in identify_join_columns()).
    4011             :      */
    4012       15784 :     forboth(lc, dpns->rtable, lc2, dpns->rtable_columns)
    4013             :     {
    4014       10126 :         RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
    4015       10126 :         deparse_columns *colinfo = (deparse_columns *) lfirst(lc2);
    4016             : 
    4017       10126 :         if (rte->rtekind == RTE_JOIN)
    4018        1498 :             set_join_column_names(dpns, rte, colinfo);
    4019             :         else
    4020        8628 :             set_relation_column_names(dpns, rte, colinfo);
    4021             :     }
    4022        5658 : }
    4023             : 
    4024             : /*
    4025             :  * set_simple_column_names: fill in column aliases for non-query situations
    4026             :  *
    4027             :  * This handles EXPLAIN and cases where we only have relation RTEs.  Without
    4028             :  * a join tree, we can't do anything smart about join RTEs, but we don't
    4029             :  * need to (note that EXPLAIN should never see join alias Vars anyway).
    4030             :  * If we do hit a join RTE we'll just process it like a non-table base RTE.
    4031             :  */
    4032             : static void
    4033       42108 : set_simple_column_names(deparse_namespace *dpns)
    4034             : {
    4035             :     ListCell   *lc;
    4036             :     ListCell   *lc2;
    4037             : 
    4038             :     /* Initialize dpns->rtable_columns to contain zeroed structs */
    4039       42108 :     dpns->rtable_columns = NIL;
    4040      119276 :     while (list_length(dpns->rtable_columns) < list_length(dpns->rtable))
    4041       77168 :         dpns->rtable_columns = lappend(dpns->rtable_columns,
    4042             :                                        palloc0(sizeof(deparse_columns)));
    4043             : 
    4044             :     /* Assign unique column aliases within each RTE */
    4045      119276 :     forboth(lc, dpns->rtable, lc2, dpns->rtable_columns)
    4046             :     {
    4047       77168 :         RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
    4048       77168 :         deparse_columns *colinfo = (deparse_columns *) lfirst(lc2);
    4049             : 
    4050       77168 :         set_relation_column_names(dpns, rte, colinfo);
    4051             :     }
    4052       42108 : }
    4053             : 
    4054             : /*
    4055             :  * has_dangerous_join_using: search jointree for unnamed JOIN USING
    4056             :  *
    4057             :  * Merged columns of a JOIN USING may act differently from either of the input
    4058             :  * columns, either because they are merged with COALESCE (in a FULL JOIN) or
    4059             :  * because an implicit coercion of the underlying input column is required.
    4060             :  * In such a case the column must be referenced as a column of the JOIN not as
    4061             :  * a column of either input.  And this is problematic if the join is unnamed
    4062             :  * (alias-less): we cannot qualify the column's name with an RTE name, since
    4063             :  * there is none.  (Forcibly assigning an alias to the join is not a solution,
    4064             :  * since that will prevent legal references to tables below the join.)
    4065             :  * To ensure that every column in the query is unambiguously referenceable,
    4066             :  * we must assign such merged columns names that are globally unique across
    4067             :  * the whole query, aliasing other columns out of the way as necessary.
    4068             :  *
    4069             :  * Because the ensuing re-aliasing is fairly damaging to the readability of
    4070             :  * the query, we don't do this unless we have to.  So, we must pre-scan
    4071             :  * the join tree to see if we have to, before starting set_using_names().
    4072             :  */
    4073             : static bool
    4074       13484 : has_dangerous_join_using(deparse_namespace *dpns, Node *jtnode)
    4075             : {
    4076       13484 :     if (IsA(jtnode, RangeTblRef))
    4077             :     {
    4078             :         /* nothing to do here */
    4079             :     }
    4080        7074 :     else if (IsA(jtnode, FromExpr))
    4081             :     {
    4082        5642 :         FromExpr   *f = (FromExpr *) jtnode;
    4083             :         ListCell   *lc;
    4084             : 
    4085       10692 :         foreach(lc, f->fromlist)
    4086             :         {
    4087        5122 :             if (has_dangerous_join_using(dpns, (Node *) lfirst(lc)))
    4088          72 :                 return true;
    4089             :         }
    4090             :     }
    4091        1432 :     else if (IsA(jtnode, JoinExpr))
    4092             :     {
    4093        1432 :         JoinExpr   *j = (JoinExpr *) jtnode;
    4094             : 
    4095             :         /* Is it an unnamed JOIN with USING? */
    4096        1432 :         if (j->alias == NULL && j->usingClause)
    4097             :         {
    4098             :             /*
    4099             :              * Yes, so check each join alias var to see if any of them are not
    4100             :              * simple references to underlying columns.  If so, we have a
    4101             :              * dangerous situation and must pick unique aliases.
    4102             :              */
    4103         286 :             RangeTblEntry *jrte = rt_fetch(j->rtindex, dpns->rtable);
    4104             : 
    4105             :             /* We need only examine the merged columns */
    4106         596 :             for (int i = 0; i < jrte->joinmergedcols; i++)
    4107             :             {
    4108         382 :                 Node       *aliasvar = list_nth(jrte->joinaliasvars, i);
    4109             : 
    4110         382 :                 if (!IsA(aliasvar, Var))
    4111          72 :                     return true;
    4112             :             }
    4113             :         }
    4114             : 
    4115             :         /* Nope, but inspect children */
    4116        1360 :         if (has_dangerous_join_using(dpns, j->larg))
    4117           0 :             return true;
    4118        1360 :         if (has_dangerous_join_using(dpns, j->rarg))
    4119           0 :             return true;
    4120             :     }
    4121             :     else
    4122           0 :         elog(ERROR, "unrecognized node type: %d",
    4123             :              (int) nodeTag(jtnode));
    4124       13340 :     return false;
    4125             : }
    4126             : 
    4127             : /*
    4128             :  * set_using_names: select column aliases to be used for merged USING columns
    4129             :  *
    4130             :  * We do this during a recursive descent of the query jointree.
    4131             :  * dpns->unique_using must already be set to determine the global strategy.
    4132             :  *
    4133             :  * Column alias info is saved in the dpns->rtable_columns list, which is
    4134             :  * assumed to be filled with pre-zeroed deparse_columns structs.
    4135             :  *
    4136             :  * parentUsing is a list of all USING aliases assigned in parent joins of
    4137             :  * the current jointree node.  (The passed-in list must not be modified.)
    4138             :  */
    4139             : static void
    4140       13802 : set_using_names(deparse_namespace *dpns, Node *jtnode, List *parentUsing)
    4141             : {
    4142       13802 :     if (IsA(jtnode, RangeTblRef))
    4143             :     {
    4144             :         /* nothing to do now */
    4145             :     }
    4146        7140 :     else if (IsA(jtnode, FromExpr))
    4147             :     {
    4148        5642 :         FromExpr   *f = (FromExpr *) jtnode;
    4149             :         ListCell   *lc;
    4150             : 
    4151       10806 :         foreach(lc, f->fromlist)
    4152        5164 :             set_using_names(dpns, (Node *) lfirst(lc), parentUsing);
    4153             :     }
    4154        1498 :     else if (IsA(jtnode, JoinExpr))
    4155             :     {
    4156        1498 :         JoinExpr   *j = (JoinExpr *) jtnode;
    4157        1498 :         RangeTblEntry *rte = rt_fetch(j->rtindex, dpns->rtable);
    4158        1498 :         deparse_columns *colinfo = deparse_columns_fetch(j->rtindex, dpns);
    4159             :         int        *leftattnos;
    4160             :         int        *rightattnos;
    4161             :         deparse_columns *leftcolinfo;
    4162             :         deparse_columns *rightcolinfo;
    4163             :         int         i;
    4164             :         ListCell   *lc;
    4165             : 
    4166             :         /* Get info about the shape of the join */
    4167        1498 :         identify_join_columns(j, rte, colinfo);
    4168        1498 :         leftattnos = colinfo->leftattnos;
    4169        1498 :         rightattnos = colinfo->rightattnos;
    4170             : 
    4171             :         /* Look up the not-yet-filled-in child deparse_columns structs */
    4172        1498 :         leftcolinfo = deparse_columns_fetch(colinfo->leftrti, dpns);
    4173        1498 :         rightcolinfo = deparse_columns_fetch(colinfo->rightrti, dpns);
    4174             : 
    4175             :         /*
    4176             :          * If this join is unnamed, then we cannot substitute new aliases at
    4177             :          * this level, so any name requirements pushed down to here must be
    4178             :          * pushed down again to the children.
    4179             :          */
    4180        1498 :         if (rte->alias == NULL)
    4181             :         {
    4182        1528 :             for (i = 0; i < colinfo->num_cols; i++)
    4183             :             {
    4184         138 :                 char       *colname = colinfo->colnames[i];
    4185             : 
    4186         138 :                 if (colname == NULL)
    4187          24 :                     continue;
    4188             : 
    4189             :                 /* Push down to left column, unless it's a system column */
    4190         114 :                 if (leftattnos[i] > 0)
    4191             :                 {
    4192         102 :                     expand_colnames_array_to(leftcolinfo, leftattnos[i]);
    4193         102 :                     leftcolinfo->colnames[leftattnos[i] - 1] = colname;
    4194             :                 }
    4195             : 
    4196             :                 /* Same on the righthand side */
    4197         114 :                 if (rightattnos[i] > 0)
    4198             :                 {
    4199         114 :                     expand_colnames_array_to(rightcolinfo, rightattnos[i]);
    4200         114 :                     rightcolinfo->colnames[rightattnos[i] - 1] = colname;
    4201             :                 }
    4202             :             }
    4203             :         }
    4204             : 
    4205             :         /*
    4206             :          * If there's a USING clause, select the USING column names and push
    4207             :          * those names down to the children.  We have two strategies:
    4208             :          *
    4209             :          * If dpns->unique_using is true, we force all USING names to be
    4210             :          * unique across the whole query level.  In principle we'd only need
    4211             :          * the names of dangerous USING columns to be globally unique, but to
    4212             :          * safely assign all USING names in a single pass, we have to enforce
    4213             :          * the same uniqueness rule for all of them.  However, if a USING
    4214             :          * column's name has been pushed down from the parent, we should use
    4215             :          * it as-is rather than making a uniqueness adjustment.  This is
    4216             :          * necessary when we're at an unnamed join, and it creates no risk of
    4217             :          * ambiguity.  Also, if there's a user-written output alias for a
    4218             :          * merged column, we prefer to use that rather than the input name;
    4219             :          * this simplifies the logic and seems likely to lead to less aliasing
    4220             :          * overall.
    4221             :          *
    4222             :          * If dpns->unique_using is false, we only need USING names to be
    4223             :          * unique within their own join RTE.  We still need to honor
    4224             :          * pushed-down names, though.
    4225             :          *
    4226             :          * Though significantly different in results, these two strategies are
    4227             :          * implemented by the same code, with only the difference of whether
    4228             :          * to put assigned names into dpns->using_names.
    4229             :          */
    4230        1498 :         if (j->usingClause)
    4231             :         {
    4232             :             /* Copy the input parentUsing list so we don't modify it */
    4233         424 :             parentUsing = list_copy(parentUsing);
    4234             : 
    4235             :             /* USING names must correspond to the first join output columns */
    4236         424 :             expand_colnames_array_to(colinfo, list_length(j->usingClause));
    4237         424 :             i = 0;
    4238        1004 :             foreach(lc, j->usingClause)
    4239             :             {
    4240         580 :                 char       *colname = strVal(lfirst(lc));
    4241             : 
    4242             :                 /* Assert it's a merged column */
    4243             :                 Assert(leftattnos[i] != 0 && rightattnos[i] != 0);
    4244             : 
    4245             :                 /* Adopt passed-down name if any, else select unique name */
    4246         580 :                 if (colinfo->colnames[i] != NULL)
    4247         102 :                     colname = colinfo->colnames[i];
    4248             :                 else
    4249             :                 {
    4250             :                     /* Prefer user-written output alias if any */
    4251         478 :                     if (rte->alias && i < list_length(rte->alias->colnames))
    4252           0 :                         colname = strVal(list_nth(rte->alias->colnames, i));
    4253             :                     /* Make it appropriately unique */
    4254         478 :                     colname = make_colname_unique(colname, dpns, colinfo);
    4255         478 :                     if (dpns->unique_using)
    4256         126 :                         dpns->using_names = lappend(dpns->using_names,
    4257             :                                                     colname);
    4258             :                     /* Save it as output column name, too */
    4259         478 :                     colinfo->colnames[i] = colname;
    4260             :                 }
    4261             : 
    4262             :                 /* Remember selected names for use later */
    4263         580 :                 colinfo->usingNames = lappend(colinfo->usingNames, colname);
    4264         580 :                 parentUsing = lappend(parentUsing, colname);
    4265             : 
    4266             :                 /* Push down to left column, unless it's a system column */
    4267         580 :                 if (leftattnos[i] > 0)
    4268             :                 {
    4269         580 :                     expand_colnames_array_to(leftcolinfo, leftattnos[i]);
    4270         580 :                     leftcolinfo->colnames[leftattnos[i] - 1] = colname;
    4271             :                 }
    4272             : 
    4273             :                 /* Same on the righthand side */
    4274         580 :                 if (rightattnos[i] > 0)
    4275             :                 {
    4276         580 :                     expand_colnames_array_to(rightcolinfo, rightattnos[i]);
    4277         580 :                     rightcolinfo->colnames[rightattnos[i] - 1] = colname;
    4278             :                 }
    4279             : 
    4280         580 :                 i++;
    4281             :             }
    4282             :         }
    4283             : 
    4284             :         /* Mark child deparse_columns structs with correct parentUsing info */
    4285        1498 :         leftcolinfo->parentUsing = parentUsing;
    4286        1498 :         rightcolinfo->parentUsing = parentUsing;
    4287             : 
    4288             :         /* Now recursively assign USING column names in children */
    4289        1498 :         set_using_names(dpns, j->larg, parentUsing);
    4290        1498 :         set_using_names(dpns, j->rarg, parentUsing);
    4291             :     }
    4292             :     else
    4293           0 :         elog(ERROR, "unrecognized node type: %d",
    4294             :              (int) nodeTag(jtnode));
    4295       13802 : }
    4296             : 
    4297             : /*
    4298             :  * set_relation_column_names: select column aliases for a non-join RTE
    4299             :  *
    4300             :  * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
    4301             :  * If any colnames entries are already filled in, those override local
    4302             :  * choices.
    4303             :  */
    4304             : static void
    4305       85796 : set_relation_column_names(deparse_namespace *dpns, RangeTblEntry *rte,
    4306             :                           deparse_columns *colinfo)
    4307             : {
    4308             :     int         ncolumns;
    4309             :     char      **real_colnames;
    4310             :     bool        changed_any;
    4311             :     int         noldcolumns;
    4312             :     int         i;
    4313             :     int         j;
    4314             : 
    4315             :     /*
    4316             :      * Construct an array of the current "real" column names of the RTE.
    4317             :      * real_colnames[] will be indexed by physical column number, with NULL
    4318             :      * entries for dropped columns.
    4319             :      */
    4320       85796 :     if (rte->rtekind == RTE_RELATION)
    4321             :     {
    4322             :         /* Relation --- look to the system catalogs for up-to-date info */
    4323             :         Relation    rel;
    4324             :         TupleDesc   tupdesc;
    4325             : 
    4326       70600 :         rel = relation_open(rte->relid, AccessShareLock);
    4327       70600 :         tupdesc = RelationGetDescr(rel);
    4328             : 
    4329       70600 :         ncolumns = tupdesc->natts;
    4330       70600 :         real_colnames = (char **) palloc(ncolumns * sizeof(char *));
    4331             : 
    4332      463360 :         for (i = 0; i < ncolumns; i++)
    4333             :         {
    4334      392760 :             Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
    4335             : 
    4336      392760 :             if (attr->attisdropped)
    4337        3040 :                 real_colnames[i] = NULL;
    4338             :             else
    4339      389720 :                 real_colnames[i] = pstrdup(NameStr(attr->attname));
    4340             :         }
    4341       70600 :         relation_close(rel, AccessShareLock);
    4342             :     }
    4343             :     else
    4344             :     {
    4345             :         /* Otherwise get the column names from eref or expandRTE() */
    4346             :         List       *colnames;
    4347             :         ListCell   *lc;
    4348             : 
    4349             :         /*
    4350             :          * Functions returning composites have the annoying property that some
    4351             :          * of the composite type's columns might have been dropped since the
    4352             :          * query was parsed.  If possible, use expandRTE() to handle that
    4353             :          * case, since it has the tedious logic needed to find out about
    4354             :          * dropped columns.  However, if we're explaining a plan, then we
    4355             :          * don't have rte->functions because the planner thinks that won't be
    4356             :          * needed later, and that breaks expandRTE().  So in that case we have
    4357             :          * to rely on rte->eref, which may lead us to report a dropped
    4358             :          * column's old name; that seems close enough for EXPLAIN's purposes.
    4359             :          *
    4360             :          * For non-RELATION, non-FUNCTION RTEs, we can just look at rte->eref,
    4361             :          * which should be sufficiently up-to-date: no other RTE types can
    4362             :          * have columns get dropped from under them after parsing.
    4363             :          */
    4364       15196 :         if (rte->rtekind == RTE_FUNCTION && rte->functions != NIL)
    4365             :         {
    4366             :             /* Since we're not creating Vars, rtindex etc. don't matter */
    4367         786 :             expandRTE(rte, 1, 0, -1, true /* include dropped */ ,
    4368             :                       &colnames, NULL);
    4369             :         }
    4370             :         else
    4371       14410 :             colnames = rte->eref->colnames;
    4372             : 
    4373       15196 :         ncolumns = list_length(colnames);
    4374       15196 :         real_colnames = (char **) palloc(ncolumns * sizeof(char *));
    4375             : 
    4376       15196 :         i = 0;
    4377       89766 :         foreach(lc, colnames)
    4378             :         {
    4379             :             /*
    4380             :              * If the column name we find here is an empty string, then it's a
    4381             :              * dropped column, so change to NULL.
    4382             :              */
    4383       74570 :             char       *cname = strVal(lfirst(lc));
    4384             : 
    4385       74570 :             if (cname[0] == '\0')
    4386          54 :                 cname = NULL;
    4387       74570 :             real_colnames[i] = cname;
    4388       74570 :             i++;
    4389             :         }
    4390             :     }
    4391             : 
    4392             :     /*
    4393             :      * Ensure colinfo->colnames has a slot for each column.  (It could be long
    4394             :      * enough already, if we pushed down a name for the last column.)  Note:
    4395             :      * it's possible that there are now more columns than there were when the
    4396             :      * query was parsed, ie colnames could be longer than rte->eref->colnames.
    4397             :      * We must assign unique aliases to the new columns too, else there could
    4398             :      * be unresolved conflicts when the view/rule is reloaded.
    4399             :      */
    4400       85796 :     expand_colnames_array_to(colinfo, ncolumns);
    4401             :     Assert(colinfo->num_cols == ncolumns);
    4402             : 
    4403             :     /*
    4404             :      * Make sufficiently large new_colnames and is_new_col arrays, too.
    4405             :      *
    4406             :      * Note: because we leave colinfo->num_new_cols zero until after the loop,
    4407             :      * colname_is_unique will not consult that array, which is fine because it
    4408             :      * would only be duplicate effort.
    4409             :      */
    4410       85796 :     colinfo->new_colnames = (char **) palloc(ncolumns * sizeof(char *));
    4411       85796 :     colinfo->is_new_col = (bool *) palloc(ncolumns * sizeof(bool));
    4412             : 
    4413             :     /*
    4414             :      * Scan the columns, select a unique alias for each one, and store it in
    4415             :      * colinfo->colnames and colinfo->new_colnames.  The former array has NULL
    4416             :      * entries for dropped columns, the latter omits them.  Also mark
    4417             :      * new_colnames entries as to whether they are new since parse time; this
    4418             :      * is the case for entries beyond the length of rte->eref->colnames.
    4419             :      */
    4420       85796 :     noldcolumns = list_length(rte->eref->colnames);
    4421       85796 :     changed_any = false;
    4422       85796 :     j = 0;
    4423      553126 :     for (i = 0; i < ncolumns; i++)
    4424             :     {
    4425      467330 :         char       *real_colname = real_colnames[i];
    4426      467330 :         char       *colname = colinfo->colnames[i];
    4427             : 
    4428             :         /* Skip dropped columns */
    4429      467330 :         if (real_colname == NULL)
    4430             :         {
    4431             :             Assert(colname == NULL);    /* colnames[i] is already NULL */
    4432        3094 :             continue;
    4433             :         }
    4434             : 
    4435             :         /* If alias already assigned, that's what to use */
    4436      464236 :         if (colname == NULL)
    4437             :         {
    4438             :             /* If user wrote an alias, prefer that over real column name */
    4439      463178 :             if (rte->alias && i < list_length(rte->alias->colnames))
    4440       40732 :                 colname = strVal(list_nth(rte->alias->colnames, i));
    4441             :             else
    4442      422446 :                 colname = real_colname;
    4443             : 
    4444             :             /* Unique-ify and insert into colinfo */
    4445      463178 :             colname = make_colname_unique(colname, dpns, colinfo);
    4446             : 
    4447      463178 :             colinfo->colnames[i] = colname;
    4448             :         }
    4449             : 
    4450             :         /* Put names of non-dropped columns in new_colnames[] too */
    4451      464236 :         colinfo->new_colnames[j] = colname;
    4452             :         /* And mark them as new or not */
    4453      464236 :         colinfo->is_new_col[j] = (i >= noldcolumns);
    4454      464236 :         j++;
    4455             : 
    4456             :         /* Remember if any assigned aliases differ from "real" name */
    4457      464236 :         if (!changed_any && strcmp(colname, real_colname) != 0)
    4458        4324 :             changed_any = true;
    4459             :     }
    4460             : 
    4461             :     /*
    4462             :      * Set correct length for new_colnames[] array.  (Note: if columns have
    4463             :      * been added, colinfo->num_cols includes them, which is not really quite
    4464             :      * right but is harmless, since any new columns must be at the end where
    4465             :      * they won't affect varattnos of pre-existing columns.)
    4466             :      */
    4467       85796 :     colinfo->num_new_cols = j;
    4468             : 
    4469             :     /*
    4470             :      * For a relation RTE, we need only print the alias column names if any
    4471             :      * are different from the underlying "real" names.  For a function RTE,
    4472             :      * always emit a complete column alias list; this is to protect against
    4473             :      * possible instability of the default column names (eg, from altering
    4474             :      * parameter names).  For tablefunc RTEs, we never print aliases, because
    4475             :      * the column names are part of the clause itself.  For other RTE types,
    4476             :      * print if we changed anything OR if there were user-written column
    4477             :      * aliases (since the latter would be part of the underlying "reality").
    4478             :      */
    4479       85796 :     if (rte->rtekind == RTE_RELATION)
    4480       70600 :         colinfo->printaliases = changed_any;
    4481       15196 :     else if (rte->rtekind == RTE_FUNCTION)
    4482        1224 :         colinfo->printaliases = true;
    4483       13972 :     else if (rte->rtekind == RTE_TABLEFUNC)
    4484         170 :         colinfo->printaliases = false;
    4485       13802 :     else if (rte->alias && rte->alias->colnames != NIL)
    4486         732 :         colinfo->printaliases = true;
    4487             :     else
    4488       13070 :         colinfo->printaliases = changed_any;
    4489       85796 : }
    4490             : 
    4491             : /*
    4492             :  * set_join_column_names: select column aliases for a join RTE
    4493             :  *
    4494             :  * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
    4495             :  * If any colnames entries are already filled in, those override local
    4496             :  * choices.  Also, names for USING columns were already chosen by
    4497             :  * set_using_names().  We further expect that column alias selection has been
    4498             :  * completed for both input RTEs.
    4499             :  */
    4500             : static void
    4501        1498 : set_join_column_names(deparse_namespace *dpns, RangeTblEntry *rte,
    4502             :                       deparse_columns *colinfo)
    4503             : {
    4504             :     deparse_columns *leftcolinfo;
    4505             :     deparse_columns *rightcolinfo;
    4506             :     bool        changed_any;
    4507             :     int         noldcolumns;
    4508             :     int         nnewcolumns;
    4509        1498 :     Bitmapset  *leftmerged = NULL;
    4510        1498 :     Bitmapset  *rightmerged = NULL;
    4511             :     int         i;
    4512             :     int         j;
    4513             :     int         ic;
    4514             :     int         jc;
    4515             : 
    4516             :     /* Look up the previously-filled-in child deparse_columns structs */
    4517        1498 :     leftcolinfo = deparse_columns_fetch(colinfo->leftrti, dpns);
    4518        1498 :     rightcolinfo = deparse_columns_fetch(colinfo->rightrti, dpns);
    4519             : 
    4520             :     /*
    4521             :      * Ensure colinfo->colnames has a slot for each column.  (It could be long
    4522             :      * enough already, if we pushed down a name for the last column.)  Note:
    4523             :      * it's possible that one or both inputs now have more columns than there
    4524             :      * were when the query was parsed, but we'll deal with that below.  We
    4525             :      * only need entries in colnames for pre-existing columns.
    4526             :      */
    4527        1498 :     noldcolumns = list_length(rte->eref->colnames);
    4528        1498 :     expand_colnames_array_to(colinfo, noldcolumns);
    4529             :     Assert(colinfo->num_cols == noldcolumns);
    4530             : 
    4531             :     /*
    4532             :      * Scan the join output columns, select an alias for each one, and store
    4533             :      * it in colinfo->colnames.  If there are USING columns, set_using_names()
    4534             :      * already selected their names, so we can start the loop at the first
    4535             :      * non-merged column.
    4536             :      */
    4537        1498 :     changed_any = false;
    4538       49084 :     for (i = list_length(colinfo->usingNames); i < noldcolumns; i++)
    4539             :     {
    4540       47586 :         char       *colname = colinfo->colnames[i];
    4541             :         char       *real_colname;
    4542             : 
    4543             :         /* Join column must refer to at least one input column */
    4544             :         Assert(colinfo->leftattnos[i] != 0 || colinfo->rightattnos[i] != 0);
    4545             : 
    4546             :         /* Get the child column name */
    4547       47586 :         if (colinfo->leftattnos[i] > 0)
    4548       33454 :             real_colname = leftcolinfo->colnames[colinfo->leftattnos[i] - 1];
    4549       14132 :         else if (colinfo->rightattnos[i] > 0)
    4550       14132 :             real_colname = rightcolinfo->colnames[colinfo->rightattnos[i] - 1];
    4551             :         else
    4552             :         {
    4553             :             /* We're joining system columns --- use eref name */
    4554           0 :             real_colname = strVal(list_nth(rte->eref->colnames, i));
    4555             :         }
    4556             : 
    4557             :         /* If child col has been dropped, no need to assign a join colname */
    4558       47586 :         if (real_colname == NULL)
    4559             :         {
    4560           6 :             colinfo->colnames[i] = NULL;
    4561           6 :             continue;
    4562             :         }
    4563             : 
    4564             :         /* In an unnamed join, just report child column names as-is */
    4565       47580 :         if (rte->alias == NULL)
    4566             :         {
    4567       47202 :             colinfo->colnames[i] = real_colname;
    4568       47202 :             continue;
    4569             :         }
    4570             : 
    4571             :         /* If alias already assigned, that's what to use */
    4572         378 :         if (colname == NULL)
    4573             :         {
    4574             :             /* If user wrote an alias, prefer that over real column name */
    4575         378 :             if (rte->alias && i < list_length(rte->alias->colnames))
    4576          96 :                 colname = strVal(list_nth(rte->alias->colnames, i));
    4577             :             else
    4578         282 :                 colname = real_colname;
    4579             : 
    4580             :             /* Unique-ify and insert into colinfo */
    4581         378 :             colname = make_colname_unique(colname, dpns, colinfo);
    4582             : 
    4583         378 :             colinfo->colnames[i] = colname;
    4584             :         }
    4585             : 
    4586             :         /* Remember if any assigned aliases differ from "real" name */
    4587         378 :         if (!changed_any && strcmp(colname, real_colname) != 0)
    4588          24 :             changed_any = true;
    4589             :     }
    4590             : 
    4591             :     /*
    4592             :      * Calculate number of columns the join would have if it were re-parsed
    4593             :      * now, and create storage for the new_colnames and is_new_col arrays.
    4594             :      *
    4595             :      * Note: colname_is_unique will be consulting new_colnames[] during the
    4596             :      * loops below, so its not-yet-filled entries must be zeroes.
    4597             :      */
    4598        2996 :     nnewcolumns = leftcolinfo->num_new_cols + rightcolinfo->num_new_cols -
    4599        1498 :         list_length(colinfo->usingNames);
    4600        1498 :     colinfo->num_new_cols = nnewcolumns;
    4601        1498 :     colinfo->new_colnames = (char **) palloc0(nnewcolumns * sizeof(char *));
    4602        1498 :     colinfo->is_new_col = (bool *) palloc0(nnewcolumns * sizeof(bool));
    4603             : 
    4604             :     /*
    4605             :      * Generating the new_colnames array is a bit tricky since any new columns
    4606             :      * added since parse time must be inserted in the right places.  This code
    4607             :      * must match the parser, which will order a join's columns as merged
    4608             :      * columns first (in USING-clause order), then non-merged columns from the
    4609             :      * left input (in attnum order), then non-merged columns from the right
    4610             :      * input (ditto).  If one of the inputs is itself a join, its columns will
    4611             :      * be ordered according to the same rule, which means newly-added columns
    4612             :      * might not be at the end.  We can figure out what's what by consulting
    4613             :      * the leftattnos and rightattnos arrays plus the input is_new_col arrays.
    4614             :      *
    4615             :      * In these loops, i indexes leftattnos/rightattnos (so it's join varattno
    4616             :      * less one), j indexes new_colnames/is_new_col, and ic/jc have similar
    4617             :      * meanings for the current child RTE.
    4618             :      */
    4619             : 
    4620             :     /* Handle merged columns; they are first and can't be new */
    4621        1498 :     i = j = 0;
    4622        2078 :     while (i < noldcolumns &&
    4623        2078 :            colinfo->leftattnos[i] != 0 &&
    4624        2078 :            colinfo->rightattnos[i] != 0)
    4625             :     {
    4626             :         /* column name is already determined and known unique */
    4627         580 :         colinfo->new_colnames[j] = colinfo->colnames[i];
    4628         580 :         colinfo->is_new_col[j] = false;
    4629             : 
    4630             :         /* build bitmapsets of child attnums of merged columns */
    4631         580 :         if (colinfo->leftattnos[i] > 0)
    4632         580 :             leftmerged = bms_add_member(leftmerged, colinfo->leftattnos[i]);
    4633         580 :         if (colinfo->rightattnos[i] > 0)
    4634         580 :             rightmerged = bms_add_member(rightmerged, colinfo->rightattnos[i]);
    4635             : 
    4636         580 :         i++, j++;
    4637             :     }
    4638             : 
    4639             :     /* Handle non-merged left-child columns */
    4640        1498 :     ic = 0;
    4641       36018 :     for (jc = 0; jc < leftcolinfo->num_new_cols; jc++)
    4642             :     {
    4643       34520 :         char       *child_colname = leftcolinfo->new_colnames[jc];
    4644             : 
    4645       34520 :         if (!leftcolinfo->is_new_col[jc])
    4646             :         {
    4647             :             /* Advance ic to next non-dropped old column of left child */
    4648       34112 :             while (ic < leftcolinfo->num_cols &&
    4649       34112 :                    leftcolinfo->colnames[ic] == NULL)
    4650          84 :                 ic++;
    4651             :             Assert(ic < leftcolinfo->num_cols);
    4652       34028 :             ic++;
    4653             :             /* If it is a merged column, we already processed it */
    4654       34028 :             if (bms_is_member(ic, leftmerged))
    4655         580 :                 continue;
    4656             :             /* Else, advance i to the corresponding existing join column */
    4657       33454 :             while (i < colinfo->num_cols &&
    4658       33454 :                    colinfo->colnames[i] == NULL)
    4659           6 :                 i++;
    4660             :             Assert(i < colinfo->num_cols);
    4661             :             Assert(ic == colinfo->leftattnos[i]);
    4662             :             /* Use the already-assigned name of this column */
    4663       33448 :             colinfo->new_colnames[j] = colinfo->colnames[i];
    4664       33448 :             i++;
    4665             :         }
    4666             :         else
    4667             :         {
    4668             :             /*
    4669             :              * Unique-ify the new child column name and assign, unless we're
    4670             :              * in an unnamed join, in which case just copy
    4671             :              */
    4672         492 :             if (rte->alias != NULL)
    4673             :             {
    4674         264 :                 colinfo->new_colnames[j] =
    4675         132 :                     make_colname_unique(child_colname, dpns, colinfo);
    4676         132 :                 if (!changed_any &&
    4677         108 :                     strcmp(colinfo->new_colnames[j], child_colname) != 0)
    4678          12 :                     changed_any = true;
    4679             :             }
    4680             :             else
    4681         360 :                 colinfo->new_colnames[j] = child_colname;
    4682             :         }
    4683             : 
    4684       33940 :         colinfo->is_new_col[j] = leftcolinfo->is_new_col[jc];
    4685       33940 :         j++;
    4686             :     }
    4687             : 
    4688             :     /* Handle non-merged right-child columns in exactly the same way */
    4689        1498 :     ic = 0;
    4690       16378 :     for (jc = 0; jc < rightcolinfo->num_new_cols; jc++)
    4691             :     {
    4692       14880 :         char       *child_colname = rightcolinfo->new_colnames[jc];
    4693             : 
    4694       14880 :         if (!rightcolinfo->is_new_col[jc])
    4695             :         {
    4696             :             /* Advance ic to next non-dropped old column of right child */
    4697       14712 :             while (ic < rightcolinfo->num_cols &&
    4698       14712 :                    rightcolinfo->colnames[ic] == NULL)
    4699           0 :                 ic++;
    4700             :             Assert(ic < rightcolinfo->num_cols);
    4701       14712 :             ic++;
    4702             :             /* If it is a merged column, we already processed it */
    4703       14712 :             if (bms_is_member(ic, rightmerged))
    4704         580 :                 continue;
    4705             :             /* Else, advance i to the corresponding existing join column */
    4706       14132 :             while (i < colinfo->num_cols &&
    4707       14132 :                    colinfo->colnames[i] == NULL)
    4708           0 :                 i++;
    4709             :             Assert(i < colinfo->num_cols);
    4710             :             Assert(ic == colinfo->rightattnos[i]);
    4711             :             /* Use the already-assigned name of this column */
    4712       14132 :             colinfo->new_colnames[j] = colinfo->colnames[i];
    4713       14132 :             i++;
    4714             :         }
    4715             :         else
    4716             :         {
    4717             :             /*
    4718             :              * Unique-ify the new child column name and assign, unless we're
    4719             :              * in an unnamed join, in which case just copy
    4720             :              */
    4721         168 :             if (rte->alias != NULL)
    4722             :             {
    4723          48 :                 colinfo->new_colnames[j] =
    4724          24 :                     make_colname_unique(child_colname, dpns, colinfo);
    4725          24 :                 if (!changed_any &&
    4726          24 :                     strcmp(colinfo->new_colnames[j], child_colname) != 0)
    4727          12 :                     changed_any = true;
    4728             :             }
    4729             :             else
    4730         144 :                 colinfo->new_colnames[j] = child_colname;
    4731             :         }
    4732             : 
    4733       14300 :         colinfo->is_new_col[j] = rightcolinfo->is_new_col[jc];
    4734       14300 :         j++;
    4735             :     }
    4736             : 
    4737             :     /* Assert we processed the right number of columns */
    4738             : #ifdef USE_ASSERT_CHECKING
    4739             :     while (i < colinfo->num_cols && colinfo->colnames[i] == NULL)
    4740             :         i++;
    4741             :     Assert(i == colinfo->num_cols);
    4742             :     Assert(j == nnewcolumns);
    4743             : #endif
    4744             : 
    4745             :     /*
    4746             :      * For a named join, print column aliases if we changed any from the child
    4747             :      * names.  Unnamed joins cannot print aliases.
    4748             :      */
    4749        1498 :     if (rte->alias != NULL)
    4750         108 :         colinfo->printaliases = changed_any;
    4751             :     else
    4752        1390 :         colinfo->printaliases = false;
    4753        1498 : }
    4754             : 
    4755             : /*
    4756             :  * colname_is_unique: is colname distinct from already-chosen column names?
    4757             :  *
    4758             :  * dpns is query-wide info, colinfo is for the column's RTE
    4759             :  */
    4760             : static bool
    4761      488780 : colname_is_unique(const char *colname, deparse_namespace *dpns,
    4762             :                   deparse_columns *colinfo)
    4763             : {
    4764             :     int         i;
    4765             :     ListCell   *lc;
    4766             : 
    4767             :     /* Check against already-assigned column aliases within RTE */
    4768     7512532 :     for (i = 0; i < colinfo->num_cols; i++)
    4769             :     {
    4770     7048270 :         char       *oldname = colinfo->colnames[i];
    4771             : 
    4772     7048270 :         if (oldname && strcmp(oldname, colname) == 0)
    4773       24518 :             return false;
    4774             :     }
    4775             : 
    4776             :     /*
    4777             :      * If we're building a new_colnames array, check that too (this will be
    4778             :      * partially but not completely redundant with the previous checks)
    4779             :      */
    4780      465534 :     for (i = 0; i < colinfo->num_new_cols; i++)
    4781             :     {
    4782        1296 :         char       *oldname = colinfo->new_colnames[i];
    4783             : 
    4784        1296 :         if (oldname && strcmp(oldname, colname) == 0)
    4785          24 :             return false;
    4786             :     }
    4787             : 
    4788             :     /* Also check against USING-column names that must be globally unique */
    4789      465078 :     foreach(lc, dpns->using_names)
    4790             :     {
    4791         882 :         char       *oldname = (char *) lfirst(lc);
    4792             : 
    4793         882 :         if (strcmp(oldname, colname) == 0)
    4794          42 :             return false;
    4795             :     }
    4796             : 
    4797             :     /* Also check against names already assigned for parent-join USING cols */
    4798      466788 :     foreach(lc, colinfo->parentUsing)
    4799             :     {
    4800        2598 :         char       *oldname = (char *) lfirst(lc);
    4801             : 
    4802        2598 :         if (strcmp(oldname, colname) == 0)
    4803           6 :             return false;
    4804             :     }
    4805             : 
    4806      464190 :     return true;
    4807             : }
    4808             : 
    4809             : /*
    4810             :  * make_colname_unique: modify colname if necessary to make it unique
    4811             :  *
    4812             :  * dpns is query-wide info, colinfo is for the column's RTE
    4813             :  */
    4814             : static char *
    4815      464190 : make_colname_unique(char *colname, deparse_namespace *dpns,
    4816             :                     deparse_columns *colinfo)
    4817             : {
    4818             :     /*
    4819             :      * If the selected name isn't unique, append digits to make it so.  For a
    4820             :      * very long input name, we might have to truncate to stay within
    4821             :      * NAMEDATALEN.
    4822             :      */
    4823      464190 :     if (!colname_is_unique(colname, dpns, colinfo))
    4824             :     {
    4825       20746 :         int         colnamelen = strlen(colname);
    4826       20746 :         char       *modname = (char *) palloc(colnamelen + 16);
    4827       20746 :         int         i = 0;
    4828             : 
    4829             :         do
    4830             :         {
    4831       24590 :             i++;
    4832             :             for (;;)
    4833             :             {
    4834       24590 :                 memcpy(modname, colname, colnamelen);
    4835       24590 :                 sprintf(modname + colnamelen, "_%d", i);
    4836       24590 :                 if (strlen(modname) < NAMEDATALEN)
    4837       24590 :                     break;
    4838             :                 /* drop chars from colname to keep all the digits */
    4839           0 :                 colnamelen = pg_mbcliplen(colname, colnamelen,
    4840             :                                           colnamelen - 1);
    4841             :             }
    4842       24590 :         } while (!colname_is_unique(modname, dpns, colinfo));
    4843       20746 :         colname = modname;
    4844             :     }
    4845      464190 :     return colname;
    4846             : }
    4847             : 
    4848             : /*
    4849             :  * expand_colnames_array_to: make colinfo->colnames at least n items long
    4850             :  *
    4851             :  * Any added array entries are initialized to zero.
    4852             :  */
    4853             : static void
    4854       89094 : expand_colnames_array_to(deparse_columns *colinfo, int n)
    4855             : {
    4856       89094 :     if (n > colinfo->num_cols)
    4857             :     {
    4858       86690 :         if (colinfo->colnames == NULL)
    4859       85274 :             colinfo->colnames = palloc0_array(char *, n);
    4860             :         else
    4861        1416 :             colinfo->colnames = repalloc0_array(colinfo->colnames, char *, colinfo->num_cols, n);
    4862       86690 :         colinfo->num_cols = n;
    4863             :     }
    4864       89094 : }
    4865             : 
    4866             : /*
    4867             :  * identify_join_columns: figure out where columns of a join come from
    4868             :  *
    4869             :  * Fills the join-specific fields of the colinfo struct, except for
    4870             :  * usingNames which is filled later.
    4871             :  */
    4872             : static void
    4873        1498 : identify_join_columns(JoinExpr *j, RangeTblEntry *jrte,
    4874             :                       deparse_columns *colinfo)
    4875             : {
    4876             :     int         numjoincols;
    4877             :     int         jcolno;
    4878             :     int         rcolno;
    4879             :     ListCell   *lc;
    4880             : 
    4881             :     /* Extract left/right child RT indexes */
    4882        1498 :     if (IsA(j->larg, RangeTblRef))
    4883         952 :         colinfo->leftrti = ((RangeTblRef *) j->larg)->rtindex;
    4884         546 :     else if (IsA(j->larg, JoinExpr))
    4885         546 :         colinfo->leftrti = ((JoinExpr *) j->larg)->rtindex;
    4886             :     else
    4887           0 :         elog(ERROR, "unrecognized node type in jointree: %d",
    4888             :              (int) nodeTag(j->larg));
    4889        1498 :     if (IsA(j->rarg, RangeTblRef))
    4890        1498 :         colinfo->rightrti = ((RangeTblRef *) j->rarg)->rtindex;
    4891           0 :     else if (IsA(j->rarg, JoinExpr))
    4892           0 :         colinfo->rightrti = ((JoinExpr *) j->rarg)->rtindex;
    4893             :     else
    4894           0 :         elog(ERROR, "unrecognized node type in jointree: %d",
    4895             :              (int) nodeTag(j->rarg));
    4896             : 
    4897             :     /* Assert children will be processed earlier than join in second pass */
    4898             :     Assert(colinfo->leftrti < j->rtindex);
    4899             :     Assert(colinfo->rightrti < j->rtindex);
    4900             : 
    4901             :     /* Initialize result arrays with zeroes */
    4902        1498 :     numjoincols = list_length(jrte->joinaliasvars);
    4903             :     Assert(numjoincols == list_length(jrte->eref->colnames));
    4904        1498 :     colinfo->leftattnos = (int *) palloc0(numjoincols * sizeof(int));
    4905        1498 :     colinfo->rightattnos = (int *) palloc0(numjoincols * sizeof(int));
    4906             : 
    4907             :     /*
    4908             :      * Deconstruct RTE's joinleftcols/joinrightcols into desired format.
    4909             :      * Recall that the column(s) merged due to USING are the first column(s)
    4910             :      * of the join output.  We need not do anything special while scanning
    4911             :      * joinleftcols, but while scanning joinrightcols we must distinguish
    4912             :      * merged from unmerged columns.
    4913             :      */
    4914        1498 :     jcolno = 0;
    4915       35532 :     foreach(lc, jrte->joinleftcols)
    4916             :     {
    4917       34034 :         int         leftattno = lfirst_int(lc);
    4918             : 
    4919       34034 :         colinfo->leftattnos[jcolno++] = leftattno;
    4920             :     }
    4921        1498 :     rcolno = 0;
    4922       16210 :     foreach(lc, jrte->joinrightcols)
    4923             :     {
    4924       14712 :         int         rightattno = lfirst_int(lc);
    4925             : 
    4926       14712 :         if (rcolno < jrte->joinmergedcols)    /* merged column? */
    4927         580 :             colinfo->rightattnos[rcolno] = rightattno;
    4928             :         else
    4929       14132 :             colinfo->rightattnos[jcolno++] = rightattno;
    4930       14712 :         rcolno++;
    4931             :     }
    4932             :     Assert(jcolno == numjoincols);
    4933        1498 : }
    4934             : 
    4935             : /*
    4936             :  * get_rtable_name: convenience function to get a previously assigned RTE alias
    4937             :  *
    4938             :  * The RTE must belong to the topmost namespace level in "context".
    4939             :  */
    4940             : static char *
    4941        6508 : get_rtable_name(int rtindex, deparse_context *context)
    4942             : {
    4943        6508 :     deparse_namespace *dpns = (deparse_namespace *) linitial(context->namespaces);
    4944             : 
    4945             :     Assert(rtindex > 0 && rtindex <= list_length(dpns->rtable_names));
    4946        6508 :     return (char *) list_nth(dpns->rtable_names, rtindex - 1);
    4947             : }
    4948             : 
    4949             : /*
    4950             :  * set_deparse_plan: set up deparse_namespace to parse subexpressions
    4951             :  * of a given Plan node
    4952             :  *
    4953             :  * This sets the plan, outer_plan, inner_plan, outer_tlist, inner_tlist,
    4954             :  * and index_tlist fields.  Caller must already have adjusted the ancestors
    4955             :  * list if necessary.  Note that the rtable, subplans, and ctes fields do
    4956             :  * not need to change when shifting attention to different plan nodes in a
    4957             :  * single plan tree.
    4958             :  */
    4959             : static void
    4960      110588 : set_deparse_plan(deparse_namespace *dpns, Plan *plan)
    4961             : {
    4962      110588 :     dpns->plan = plan;
    4963             : 
    4964             :     /*
    4965             :      * We special-case Append and MergeAppend to pretend that the first child
    4966             :      * plan is the OUTER referent; we have to interpret OUTER Vars in their
    4967             :      * tlists according to one of the children, and the first one is the most
    4968             :      * natural choice.
    4969             :      */
    4970      110588 :     if (IsA(plan, Append))
    4971        3840 :         dpns->outer_plan = linitial(((Append *) plan)->appendplans);
    4972      106748 :     else if (IsA(plan, MergeAppend))
    4973         468 :         dpns->outer_plan = linitial(((MergeAppend *) plan)->mergeplans);
    4974             :     else
    4975      106280 :         dpns->outer_plan = outerPlan(plan);
    4976             : 
    4977      110588 :     if (dpns->outer_plan)
    4978       49744 :         dpns->outer_tlist = dpns->outer_plan->targetlist;
    4979             :     else
    4980       60844 :         dpns->outer_tlist = NIL;
    4981             : 
    4982             :     /*
    4983             :      * For a SubqueryScan, pretend the subplan is INNER referent.  (We don't
    4984             :      * use OUTER because that could someday conflict with the normal meaning.)
    4985             :      * Likewise, for a CteScan, pretend the subquery's plan is INNER referent.
    4986             :      * For a WorkTableScan, locate the parent RecursiveUnion plan node and use
    4987             :      * that as INNER referent.
    4988             :      *
    4989             :      * For MERGE, pretend the ModifyTable's source plan (its outer plan) is
    4990             :      * INNER referent.  This is the join from the target relation to the data
    4991             :      * source, and all INNER_VAR Vars in other parts of the query refer to its
    4992             :      * targetlist.
    4993             :      *
    4994             :      * For ON CONFLICT .. UPDATE we just need the inner tlist to point to the
    4995             :      * excluded expression's tlist. (Similar to the SubqueryScan we don't want
    4996             :      * to reuse OUTER, it's used for RETURNING in some modify table cases,
    4997             :      * although not INSERT .. CONFLICT).
    4998             :      */
    4999      110588 :     if (IsA(plan, SubqueryScan))
    5000         632 :         dpns->inner_plan = ((SubqueryScan *) plan)->subplan;
    5001      109956 :     else if (IsA(plan, CteScan))
    5002         552 :         dpns->inner_plan = list_nth(dpns->subplans,
    5003         552 :                                     ((CteScan *) plan)->ctePlanId - 1);
    5004      109404 :     else if (IsA(plan, WorkTableScan))
    5005         174 :         dpns->inner_plan = find_recursive_union(dpns,
    5006             :                                                 (WorkTableScan *) plan);
    5007      109230 :     else if (IsA(plan, ModifyTable))
    5008             :     {
    5009         270 :         if (((ModifyTable *) plan)->operation == CMD_MERGE)
    5010          60 :             dpns->inner_plan = outerPlan(plan);
    5011             :         else
    5012         210 :             dpns->inner_plan = plan;
    5013             :     }
    5014             :     else
    5015      108960 :         dpns->inner_plan = innerPlan(plan);
    5016             : 
    5017      110588 :     if (IsA(plan, ModifyTable) && ((ModifyTable *) plan)->operation == CMD_INSERT)
    5018         140 :         dpns->inner_tlist = ((ModifyTable *) plan)->exclRelTlist;
    5019      110448 :     else if (dpns->inner_plan)
    5020       18512 :         dpns->inner_tlist = dpns->inner_plan->targetlist;
    5021             :     else
    5022       91936 :         dpns->inner_tlist = NIL;
    5023             : 
    5024             :     /* Set up referent for INDEX_VAR Vars, if needed */
    5025      110588 :     if (IsA(plan, IndexOnlyScan))
    5026        2846 :         dpns->index_tlist = ((IndexOnlyScan *) plan)->indextlist;
    5027      107742 :     else if (IsA(plan, ForeignScan))
    5028        2744 :         dpns->index_tlist = ((ForeignScan *) plan)->fdw_scan_tlist;
    5029      104998 :     else if (IsA(plan, CustomScan))
    5030           0 :         dpns->index_tlist = ((CustomScan *) plan)->custom_scan_tlist;
    5031             :     else
    5032      104998 :         dpns->index_tlist = NIL;
    5033      110588 : }
    5034             : 
    5035             : /*
    5036             :  * Locate the ancestor plan node that is the RecursiveUnion generating
    5037             :  * the WorkTableScan's work table.  We can match on wtParam, since that
    5038             :  * should be unique within the plan tree.
    5039             :  */
    5040             : static Plan *
    5041         174 : find_recursive_union(deparse_namespace *dpns, WorkTableScan *wtscan)
    5042             : {
    5043             :     ListCell   *lc;
    5044             : 
    5045         438 :     foreach(lc, dpns->ancestors)
    5046             :     {
    5047         438 :         Plan       *ancestor = (Plan *) lfirst(lc);
    5048             : 
    5049         438 :         if (IsA(ancestor, RecursiveUnion) &&
    5050         174 :             ((RecursiveUnion *) ancestor)->wtParam == wtscan->wtParam)
    5051         174 :             return ancestor;
    5052             :     }
    5053           0 :     elog(ERROR, "could not find RecursiveUnion for WorkTableScan with wtParam %d",
    5054             :          wtscan->wtParam);
    5055             :     return NULL;
    5056             : }
    5057             : 
    5058             : /*
    5059             :  * push_child_plan: temporarily transfer deparsing attention to a child plan
    5060             :  *
    5061             :  * When expanding an OUTER_VAR or INNER_VAR reference, we must adjust the
    5062             :  * deparse context in case the referenced expression itself uses
    5063             :  * OUTER_VAR/INNER_VAR.  We modify the top stack entry in-place to avoid
    5064             :  * affecting levelsup issues (although in a Plan tree there really shouldn't
    5065             :  * be any).
    5066             :  *
    5067             :  * Caller must provide a local deparse_namespace variable to save the
    5068             :  * previous state for pop_child_plan.
    5069             :  */
    5070             : static void
    5071       59566 : push_child_plan(deparse_namespace *dpns, Plan *plan,
    5072             :                 deparse_namespace *save_dpns)
    5073             : {
    5074             :     /* Save state for restoration later */
    5075       59566 :     *save_dpns = *dpns;
    5076             : 
    5077             :     /* Link current plan node into ancestors list */
    5078       59566 :     dpns->ancestors = lcons(dpns->plan, dpns->ancestors);
    5079             : 
    5080             :     /* Set attention on selected child */
    5081       59566 :     set_deparse_plan(dpns, plan);
    5082       59566 : }
    5083             : 
    5084             : /*
    5085             :  * pop_child_plan: undo the effects of push_child_plan
    5086             :  */
    5087             : static void
    5088       59566 : pop_child_plan(deparse_namespace *dpns, deparse_namespace *save_dpns)
    5089             : {
    5090             :     List       *ancestors;
    5091             : 
    5092             :     /* Get rid of ancestors list cell added by push_child_plan */
    5093       59566 :     ancestors = list_delete_first(dpns->ancestors);
    5094             : 
    5095             :     /* Restore fields changed by push_child_plan */
    5096       59566 :     *dpns = *save_dpns;
    5097             : 
    5098             :     /* Make sure dpns->ancestors is right (may be unnecessary) */
    5099       59566 :     dpns->ancestors = ancestors;
    5100       59566 : }
    5101             : 
    5102             : /*
    5103             :  * push_ancestor_plan: temporarily transfer deparsing attention to an
    5104             :  * ancestor plan
    5105             :  *
    5106             :  * When expanding a Param reference, we must adjust the deparse context
    5107             :  * to match the plan node that contains the expression being printed;
    5108             :  * otherwise we'd fail if that expression itself contains a Param or
    5109             :  * OUTER_VAR/INNER_VAR/INDEX_VAR variable.
    5110             :  *
    5111             :  * The target ancestor is conveniently identified by the ListCell holding it
    5112             :  * in dpns->ancestors.
    5113             :  *
    5114             :  * Caller must provide a local deparse_namespace variable to save the
    5115             :  * previous state for pop_ancestor_plan.
    5116             :  */
    5117             : static void
    5118        3718 : push_ancestor_plan(deparse_namespace *dpns, ListCell *ancestor_cell,
    5119             :                    deparse_namespace *save_dpns)
    5120             : {
    5121        3718 :     Plan       *plan = (Plan *) lfirst(ancestor_cell);
    5122             : 
    5123             :     /* Save state for restoration later */
    5124        3718 :     *save_dpns = *dpns;
    5125             : 
    5126             :     /* Build a new ancestor list with just this node's ancestors */
    5127        3718 :     dpns->ancestors =
    5128        3718 :         list_copy_tail(dpns->ancestors,
    5129        3718 :                        list_cell_number(dpns->ancestors, ancestor_cell) + 1);
    5130             : 
    5131             :     /* Set attention on selected ancestor */
    5132        3718 :     set_deparse_plan(dpns, plan);
    5133        3718 : }
    5134             : 
    5135             : /*
    5136             :  * pop_ancestor_plan: undo the effects of push_ancestor_plan
    5137             :  */
    5138             : static void
    5139        3718 : pop_ancestor_plan(deparse_namespace *dpns, deparse_namespace *save_dpns)
    5140             : {
    5141             :     /* Free the ancestor list made in push_ancestor_plan */
    5142        3718 :     list_free(dpns->ancestors);
    5143             : 
    5144             :     /* Restore fields changed by push_ancestor_plan */
    5145        3718 :     *dpns = *save_dpns;
    5146        3718 : }
    5147             : 
    5148             : 
    5149             : /* ----------
    5150             :  * make_ruledef         - reconstruct the CREATE RULE command
    5151             :  *                for a given pg_rewrite tuple
    5152             :  * ----------
    5153             :  */
    5154             : static void
    5155         558 : make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,
    5156             :              int prettyFlags)
    5157             : {
    5158             :     char       *rulename;
    5159             :     char        ev_type;
    5160             :     Oid         ev_class;
    5161             :     bool        is_instead;
    5162             :     char       *ev_qual;
    5163             :     char       *ev_action;
    5164             :     List       *actions;
    5165             :     Relation    ev_relation;
    5166         558 :     TupleDesc   viewResultDesc = NULL;
    5167             :     int         fno;
    5168             :     Datum       dat;
    5169             :     bool        isnull;
    5170             : 
    5171             :     /*
    5172             :      * Get the attribute values from the rules tuple
    5173             :      */
    5174         558 :     fno = SPI_fnumber(rulettc, "rulename");
    5175         558 :     dat = SPI_getbinval(ruletup, rulettc, fno, &isnull);
    5176             :     Assert(!isnull);
    5177         558 :     rulename = NameStr(*(DatumGetName(dat)));
    5178             : 
    5179         558 :     fno = SPI_fnumber(rulettc, "ev_type");
    5180         558 :     dat = SPI_getbinval(ruletup, rulettc, fno, &isnull);
    5181             :     Assert(!isnull);
    5182         558 :     ev_type = DatumGetChar(dat);
    5183             : 
    5184         558 :     fno = SPI_fnumber(rulettc, "ev_class");
    5185         558 :     dat = SPI_getbinval(ruletup, rulettc, fno, &isnull);
    5186             :     Assert(!isnull);
    5187         558 :     ev_class = DatumGetObjectId(dat);
    5188             : 
    5189         558 :     fno = SPI_fnumber(rulettc, "is_instead");
    5190         558 :     dat = SPI_getbinval(ruletup, rulettc, fno, &isnull);
    5191             :     Assert(!isnull);
    5192         558 :     is_instead = DatumGetBool(dat);
    5193             : 
    5194         558 :     fno = SPI_fnumber(rulettc, "ev_qual");
    5195         558 :     ev_qual = SPI_getvalue(ruletup, rulettc, fno);
    5196             :     Assert(ev_qual != NULL);
    5197             : 
    5198         558 :     fno = SPI_fnumber(rulettc, "ev_action");
    5199         558 :     ev_action = SPI_getvalue(ruletup, rulettc, fno);
    5200             :     Assert(ev_action != NULL);
    5201         558 :     actions = (List *) stringToNode(ev_action);
    5202         558 :     if (actions == NIL)
    5203           0 :         elog(ERROR, "invalid empty ev_action list");
    5204             : 
    5205         558 :     ev_relation = table_open(ev_class, AccessShareLock);
    5206             : 
    5207             :     /*
    5208             :      * Build the rules definition text
    5209             :      */
    5210         558 :     appendStringInfo(buf, "CREATE RULE %s AS",
    5211             :                      quote_identifier(rulename));
    5212             : 
    5213         558 :     if (prettyFlags & PRETTYFLAG_INDENT)
    5214         558 :         appendStringInfoString(buf, "\n    ON ");
    5215             :     else
    5216           0 :         appendStringInfoString(buf, " ON ");
    5217             : 
    5218             :     /* The event the rule is fired for */
    5219         558 :     switch (ev_type)
    5220             :     {
    5221           6 :         case '1':
    5222           6 :             appendStringInfoString(buf, "SELECT");
    5223           6 :             viewResultDesc = RelationGetDescr(ev_relation);
    5224           6 :             break;
    5225             : 
    5226         154 :         case '2':
    5227         154 :             appendStringInfoString(buf, "UPDATE");
    5228         154 :             break;
    5229             : 
    5230         294 :         case '3':
    5231         294 :             appendStringInfoString(buf, "INSERT");
    5232         294 :             break;
    5233             : 
    5234         104 :         case '4':
    5235         104 :             appendStringInfoString(buf, "DELETE");
    5236         104 :             break;
    5237             : 
    5238           0 :         default:
    5239           0 :             ereport(ERROR,
    5240             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    5241             :                      errmsg("rule \"%s\" has unsupported event type %d",
    5242             :                             rulename, ev_type)));
    5243             :             break;
    5244             :     }
    5245             : 
    5246             :     /* The relation the rule is fired on */
    5247         558 :     appendStringInfo(buf, " TO %s",
    5248         558 :                      (prettyFlags & PRETTYFLAG_SCHEMA) ?
    5249         114 :                      generate_relation_name(ev_class, NIL) :
    5250         444 :                      generate_qualified_relation_name(ev_class));
    5251             : 
    5252             :     /* If the rule has an event qualification, add it */
    5253         558 :     if (strcmp(ev_qual, "<>") != 0)
    5254             :     {
    5255             :         Node       *qual;
    5256             :         Query      *query;
    5257             :         deparse_context context;
    5258             :         deparse_namespace dpns;
    5259             : 
    5260         122 :         if (prettyFlags & PRETTYFLAG_INDENT)
    5261         122 :             appendStringInfoString(buf, "\n  ");
    5262         122 :         appendStringInfoString(buf, " WHERE ");
    5263             : 
    5264         122 :         qual = stringToNode(ev_qual);
    5265             : 
    5266             :         /*
    5267             :          * We need to make a context for recognizing any Vars in the qual
    5268             :          * (which can only be references to OLD and NEW).  Use the rtable of
    5269             :          * the first query in the action list for this purpose.
    5270             :          */
    5271         122 :         query = (Query *) linitial(actions);
    5272             : 
    5273             :         /*
    5274             :          * If the action is INSERT...SELECT, OLD/NEW have been pushed down
    5275             :          * into the SELECT, and that's what we need to look at. (Ugly kluge
    5276             :          * ... try to fix this when we redesign querytrees.)
    5277             :          */
    5278         122 :         query = getInsertSelectQuery(query, NULL);
    5279             : 
    5280             :         /* Must acquire locks right away; see notes in get_query_def() */
    5281         122 :         AcquireRewriteLocks(query, false, false);
    5282             : 
    5283         122 :         context.buf = buf;
    5284         122 :         context.namespaces = list_make1(&dpns);
    5285         122 :         context.resultDesc = NULL;
    5286         122 :         context.targetList = NIL;
    5287         122 :         context.windowClause = NIL;
    5288         122 :         context.varprefix = (list_length(query->rtable) != 1);
    5289         122 :         context.prettyFlags = prettyFlags;
    5290         122 :         context.wrapColumn = WRAP_COLUMN_DEFAULT;
    5291         122 :         context.indentLevel = PRETTYINDENT_STD;
    5292         122 :         context.colNamesVisible = true;
    5293         122 :         context.inGroupBy = false;
    5294         122 :         context.varInOrderBy = false;
    5295         122 :         context.appendparents = NULL;
    5296             : 
    5297         122 :         set_deparse_for_query(&dpns, query, NIL);
    5298             : 
    5299         122 :         get_rule_expr(qual, &context, false);
    5300             :     }
    5301             : 
    5302         558 :     appendStringInfoString(buf, " DO ");
    5303             : 
    5304             :     /* The INSTEAD keyword (if so) */
    5305         558 :     if (is_instead)
    5306         330 :         appendStringInfoString(buf, "INSTEAD ");
    5307             : 
    5308             :     /* Finally the rules actions */
    5309         558 :     if (list_length(actions) > 1)
    5310             :     {
    5311             :         ListCell   *action;
    5312             :         Query      *query;
    5313             : 
    5314          20 :         appendStringInfoChar(buf, '(');
    5315          60 :         foreach(action, actions)
    5316             :         {
    5317          40 :             query = (Query *) lfirst(action);
    5318          40 :             get_query_def(query, buf, NIL, viewResultDesc, true,
    5319             :                           prettyFlags, WRAP_COLUMN_DEFAULT, 0);
    5320          40 :             if (prettyFlags)
    5321          40 :                 appendStringInfoString(buf, ";\n");
    5322             :             else
    5323           0 :                 appendStringInfoString(buf, "; ");
    5324             :         }
    5325          20 :         appendStringInfoString(buf, ");");
    5326             :     }
    5327             :     else
    5328             :     {
    5329             :         Query      *query;
    5330             : 
    5331         538 :         query = (Query *) linitial(actions);
    5332         538 :         get_query_def(query, buf, NIL, viewResultDesc, true,
    5333             :                       prettyFlags, WRAP_COLUMN_DEFAULT, 0);
    5334         538 :         appendStringInfoChar(buf, ';');
    5335             :     }
    5336             : 
    5337         558 :     table_close(ev_relation, AccessShareLock);
    5338         558 : }
    5339             : 
    5340             : 
    5341             : /* ----------
    5342             :  * make_viewdef         - reconstruct the SELECT part of a
    5343             :  *                view rewrite rule
    5344             :  * ----------
    5345             :  */
    5346             : static void
    5347        3402 : make_viewdef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,
    5348             :              int prettyFlags, int wrapColumn)
    5349             : {
    5350             :     Query      *query;
    5351             :     char        ev_type;
    5352             :     Oid         ev_class;
    5353             :     bool        is_instead;
    5354             :     char       *ev_qual;
    5355             :     char       *ev_action;
    5356             :     List       *actions;
    5357             :     Relation    ev_relation;
    5358             :     int         fno;
    5359             :     Datum       dat;
    5360             :     bool        isnull;
    5361             : 
    5362             :     /*
    5363             :      * Get the attribute values from the rules tuple
    5364             :      */
    5365        3402 :     fno = SPI_fnumber(rulettc, "ev_type");
    5366        3402 :     dat = SPI_getbinval(ruletup, rulettc, fno, &isnull);
    5367             :     Assert(!isnull);
    5368        3402 :     ev_type = DatumGetChar(dat);
    5369             : 
    5370        3402 :     fno = SPI_fnumber(rulettc, "ev_class");
    5371        3402 :     dat = SPI_getbinval(ruletup, rulettc, fno, &isnull);
    5372             :     Assert(!isnull);
    5373        3402 :     ev_class = DatumGetObjectId(dat);
    5374             : 
    5375        3402 :     fno = SPI_fnumber(rulettc, "is_instead");
    5376        3402 :     dat = SPI_getbinval(ruletup, rulettc, fno, &isnull);
    5377             :     Assert(!isnull);
    5378        3402 :     is_instead = DatumGetBool(dat);
    5379             : 
    5380        3402 :     fno = SPI_fnumber(rulettc, "ev_qual");
    5381        3402 :     ev_qual = SPI_getvalue(ruletup, rulettc, fno);
    5382             :     Assert(ev_qual != NULL);
    5383             : 
    5384        3402 :     fno = SPI_fnumber(rulettc, "ev_action");
    5385        3402 :     ev_action = SPI_getvalue(ruletup, rulettc, fno);
    5386             :     Assert(ev_action != NULL);
    5387        3402 :     actions = (List *) stringToNode(ev_action);
    5388             : 
    5389        3402 :     if (list_length(actions) != 1)
    5390             :     {
    5391             :         /* keep output buffer empty and leave */
    5392           0 :         return;
    5393             :     }
    5394             : 
    5395        3402 :     query = (Query *) linitial(actions);
    5396             : 
    5397        3402 :     if (ev_type != '1' || !is_instead ||
    5398        3402 :         strcmp(ev_qual, "<>") != 0 || query->commandType != CMD_SELECT)
    5399             :     {
    5400             :         /* keep output buffer empty and leave */
    5401           0 :         return;
    5402             :     }
    5403             : 
    5404        3402 :     ev_relation = table_open(ev_class, AccessShareLock);
    5405             : 
    5406        3402 :     get_query_def(query, buf, NIL, RelationGetDescr(ev_relation), true,
    5407             :                   prettyFlags, wrapColumn, 0);
    5408        3402 :     appendStringInfoChar(buf, ';');
    5409             : 
    5410        3402 :     table_close(ev_relation, AccessShareLock);
    5411             : }
    5412             : 
    5413             : 
    5414             : /* ----------
    5415             :  * get_query_def            - Parse back one query parsetree
    5416             :  *
    5417             :  * query: parsetree to be displayed
    5418             :  * buf: output text is appended to buf
    5419             :  * parentnamespace: list (initially empty) of outer-level deparse_namespace's
    5420             :  * resultDesc: if not NULL, the output tuple descriptor for the view
    5421             :  *      represented by a SELECT query.  We use the column names from it
    5422             :  *      to label SELECT output columns, in preference to names in the query
    5423             :  * colNamesVisible: true if the surrounding context cares about the output
    5424             :  *      column names at all (as, for example, an EXISTS() context does not);
    5425             :  *      when false, we can suppress dummy column labels such as "?column?"
    5426             :  * prettyFlags: bitmask of PRETTYFLAG_XXX options
    5427             :  * wrapColumn: maximum line length, or -1 to disable wrapping
    5428             :  * startIndent: initial indentation amount
    5429             :  * ----------
    5430             :  */
    5431             : static void
    5432        5500 : get_query_def(Query *query, StringInfo buf, List *parentnamespace,
    5433             :               TupleDesc resultDesc, bool colNamesVisible,
    5434             :               int prettyFlags, int wrapColumn, int startIndent)
    5435             : {
    5436             :     deparse_context context;
    5437             :     deparse_namespace dpns;
    5438             : 
    5439             :     /* Guard against excessively long or deeply-nested queries */
    5440        5500 :     CHECK_FOR_INTERRUPTS();
    5441        5500 :     check_stack_depth();
    5442             : 
    5443             :     /*
    5444             :      * Before we begin to examine the query, acquire locks on referenced
    5445             :      * relations, and fix up deleted columns in JOIN RTEs.  This ensures
    5446             :      * consistent results.  Note we assume it's OK to scribble on the passed
    5447             :      * querytree!
    5448             :      *
    5449             :      * We are only deparsing the query (we are not about to execute it), so we
    5450             :      * only need AccessShareLock on the relations it mentions.
    5451             :      */
    5452        5500 :     AcquireRewriteLocks(query, false, false);
    5453             : 
    5454        5500 :     context.buf = buf;
    5455        5500 :     context.namespaces = lcons(&dpns, list_copy(parentnamespace));
    5456        5500 :     context.resultDesc = NULL;
    5457        5500 :     context.targetList = NIL;
    5458        5500 :     context.windowClause = NIL;
    5459        9480 :     context.varprefix = (parentnamespace != NIL ||
    5460        3980 :                          list_length(query->rtable) != 1);
    5461        5500 :     context.prettyFlags = prettyFlags;
    5462        5500 :     context.wrapColumn = wrapColumn;
    5463        5500 :     context.indentLevel = startIndent;
    5464        5500 :     context.colNamesVisible = colNamesVisible;
    5465        5500 :     context.inGroupBy = false;
    5466        5500 :     context.varInOrderBy = false;
    5467        5500 :     context.appendparents = NULL;
    5468             : 
    5469        5500 :     set_deparse_for_query(&dpns, query, parentnamespace);
    5470             : 
    5471        5500 :     switch (query->commandType)
    5472             :     {
    5473        4884 :         case CMD_SELECT:
    5474             :             /* We set context.resultDesc only if it's a SELECT */
    5475        4884 :             context.resultDesc = resultDesc;
    5476        4884 :             get_select_query_def(query, &context);
    5477        4884 :             break;
    5478             : 
    5479         130 :         case CMD_UPDATE:
    5480         130 :             get_update_query_def(query, &context);
    5481         130 :             break;
    5482             : 
    5483         340 :         case CMD_INSERT:
    5484         340 :             get_insert_query_def(query, &context);
    5485         340 :             break;
    5486             : 
    5487          76 :         case CMD_DELETE:
    5488          76 :             get_delete_query_def(query, &context);
    5489          76 :             break;
    5490             : 
    5491          12 :         case CMD_MERGE:
    5492          12 :             get_merge_query_def(query, &context);
    5493          12 :             break;
    5494             : 
    5495          42 :         case CMD_NOTHING:
    5496          42 :             appendStringInfoString(buf, "NOTHING");
    5497          42 :             break;
    5498             : 
    5499          16 :         case CMD_UTILITY:
    5500          16 :             get_utility_query_def(query, &context);
    5501          16 :             break;
    5502             : 
    5503           0 :         default:
    5504           0 :             elog(ERROR, "unrecognized query command type: %d",
    5505             :                  query->commandType);
    5506             :             break;
    5507             :     }
    5508        5500 : }
    5509             : 
    5510             : /* ----------
    5511             :  * get_values_def           - Parse back a VALUES list
    5512             :  * ----------
    5513             :  */
    5514             : static void
    5515         272 : get_values_def(List *values_lists, deparse_context *context)
    5516             : {
    5517         272 :     StringInfo  buf = context->buf;
    5518         272 :     bool        first_list = true;
    5519             :     ListCell   *vtl;
    5520             : 
    5521         272 :     appendStringInfoString(buf, "VALUES ");
    5522             : 
    5523         778 :     foreach(vtl, values_lists)
    5524             :     {
    5525         506 :         List       *sublist = (List *) lfirst(vtl);
    5526         506 :         bool        first_col = true;
    5527             :         ListCell   *lc;
    5528             : 
    5529         506 :         if (first_list)
    5530         272 :             first_list = false;
    5531             :         else
    5532         234 :             appendStringInfoString(buf, ", ");
    5533             : 
    5534         506 :         appendStringInfoChar(buf, '(');
    5535        1958 :         foreach(lc, sublist)
    5536             :         {
    5537        1452 :             Node       *col = (Node *) lfirst(lc);
    5538             : 
    5539        1452 :             if (first_col)
    5540         506 :                 first_col = false;
    5541             :             else
    5542         946 :                 appendStringInfoChar(buf, ',');
    5543             : 
    5544             :             /*
    5545             :              * Print the value.  Whole-row Vars need special treatment.
    5546             :              */
    5547        1452 :             get_rule_expr_toplevel(col, context, false);
    5548             :         }
    5549         506 :         appendStringInfoChar(buf, ')');
    5550             :     }
    5551         272 : }
    5552             : 
    5553             : /* ----------
    5554             :  * get_with_clause          - Parse back a WITH clause
    5555             :  * ----------
    5556             :  */
    5557             : static void
    5558        5442 : get_with_clause(Query *query, deparse_context *context)
    5559             : {
    5560        5442 :     StringInfo  buf = context->buf;
    5561             :     const char *sep;
    5562             :     ListCell   *l;
    5563             : 
    5564        5442 :     if (query->cteList == NIL)
    5565        5352 :         return;
    5566             : 
    5567          90 :     if (PRETTY_INDENT(context))
    5568             :     {
    5569          90 :         context->indentLevel += PRETTYINDENT_STD;
    5570          90 :         appendStringInfoChar(buf, ' ');
    5571             :     }
    5572             : 
    5573          90 :     if (query->hasRecursive)
    5574          56 :         sep = "WITH RECURSIVE ";
    5575             :     else
    5576          34 :         sep = "WITH ";
    5577         218 :     foreach(l, query->cteList)
    5578             :     {
    5579         128 :         CommonTableExpr *cte = (CommonTableExpr *) lfirst(l);
    5580             : 
    5581         128 :         appendStringInfoString(buf, sep);
    5582         128 :         appendStringInfoString(buf, quote_identifier(cte->ctename));
    5583         128 :         if (cte->aliascolnames)
    5584             :         {
    5585          56 :             bool        first = true;
    5586             :             ListCell   *col;
    5587             : 
    5588          56 :             appendStringInfoChar(buf, '(');
    5589         148 :             foreach(col, cte->aliascolnames)
    5590             :             {
    5591          92 :                 if (first)
    5592          56 :                     first = false;
    5593             :                 else
    5594          36 :                     appendStringInfoString(buf, ", ");
    5595          92 :                 appendStringInfoString(buf,
    5596          92 :                                        quote_identifier(strVal(lfirst(col))));
    5597             :             }
    5598          56 :             appendStringInfoChar(buf, ')');
    5599             :         }
    5600         128 :         appendStringInfoString(buf, " AS ");
    5601         128 :         switch (cte->ctematerialized)
    5602             :         {
    5603         110 :             case CTEMaterializeDefault:
    5604         110 :                 break;
    5605          18 :             case CTEMaterializeAlways:
    5606          18 :                 appendStringInfoString(buf, "MATERIALIZED ");
    5607          18 :                 break;
    5608           0 :             case CTEMaterializeNever:
    5609           0 :                 appendStringInfoString(buf, "NOT MATERIALIZED ");
    5610           0 :                 break;
    5611             :         }
    5612         128 :         appendStringInfoChar(buf, '(');
    5613         128 :         if (PRETTY_INDENT(context))
    5614         128 :             appendContextKeyword(context, "", 0, 0, 0);
    5615         128 :         get_query_def((Query *) cte->ctequery, buf, context->namespaces, NULL,
    5616             :                       true,
    5617             :                       context->prettyFlags, context->wrapColumn,
    5618             :                       context->indentLevel);
    5619         128 :         if (PRETTY_INDENT(context))
    5620         128 :             appendContextKeyword(context, "", 0, 0, 0);
    5621         128 :         appendStringInfoChar(buf, ')');
    5622             : 
    5623         128 :         if (cte->search_clause)
    5624             :         {
    5625           6 :             bool        first = true;
    5626             :             ListCell   *lc;
    5627             : 
    5628           6 :             appendStringInfo(buf, " SEARCH %s FIRST BY ",
    5629           6 :                              cte->search_clause->search_breadth_first ? "BREADTH" : "DEPTH");
    5630             : 
    5631          18 :             foreach(lc, cte->search_clause->search_col_list)
    5632             :             {
    5633          12 :                 if (first)
    5634           6 :                     first = false;
    5635             :                 else
    5636           6 :                     appendStringInfoString(buf, ", ");
    5637          12 :                 appendStringInfoString(buf,
    5638          12 :                                        quote_identifier(strVal(lfirst(lc))));
    5639             :             }
    5640             : 
    5641           6 :             appendStringInfo(buf, " SET %s", quote_identifier(cte->search_clause->search_seq_column));
    5642             :         }
    5643             : 
    5644         128 :         if (cte->cycle_clause)
    5645             :         {
    5646          12 :             bool        first = true;
    5647             :             ListCell   *lc;
    5648             : 
    5649          12 :             appendStringInfoString(buf, " CYCLE ");
    5650             : 
    5651          36 :             foreach(lc, cte->cycle_clause->cycle_col_list)
    5652             :             {
    5653          24 :                 if (first)
    5654          12 :                     first = false;
    5655             :                 else
    5656          12 :                     appendStringInfoString(buf, ", ");
    5657          24 :                 appendStringInfoString(buf,
    5658          24 :                                        quote_identifier(strVal(lfirst(lc))));
    5659             :             }
    5660             : 
    5661          12 :             appendStringInfo(buf, " SET %s", quote_identifier(cte->cycle_clause->cycle_mark_column));
    5662             : 
    5663             :             {
    5664          12 :                 Const      *cmv = castNode(Const, cte->cycle_clause->cycle_mark_value);
    5665          12 :                 Const      *cmd = castNode(Const, cte->cycle_clause->cycle_mark_default);
    5666             : 
    5667          18 :                 if (!(cmv->consttype == BOOLOID && !cmv->constisnull && DatumGetBool(cmv->constvalue) == true &&
    5668           6 :                       cmd->consttype == BOOLOID && !cmd->constisnull && DatumGetBool(cmd->constvalue) == false))
    5669             :                 {
    5670           6 :                     appendStringInfoString(buf, " TO ");
    5671           6 :                     get_rule_expr(cte->cycle_clause->cycle_mark_value, context, false);
    5672           6 :                     appendStringInfoString(buf, " DEFAULT ");
    5673           6 :                     get_rule_expr(cte->cycle_clause->cycle_mark_default, context, false);
    5674             :                 }
    5675             :             }
    5676             : 
    5677          12 :             appendStringInfo(buf, " USING %s", quote_identifier(cte->cycle_clause->cycle_path_column));
    5678             :         }
    5679             : 
    5680         128 :         sep = ", ";
    5681             :     }
    5682             : 
    5683          90 :     if (PRETTY_INDENT(context))
    5684             :     {
    5685          90 :         context->indentLevel -= PRETTYINDENT_STD;
    5686          90 :         appendContextKeyword(context, "", 0, 0, 0);
    5687             :     }
    5688             :     else
    5689           0 :         appendStringInfoChar(buf, ' ');
    5690             : }
    5691             : 
    5692             : /* ----------
    5693             :  * get_select_query_def         - Parse back a SELECT parsetree
    5694             :  * ----------
    5695             :  */
    5696             : static void
    5697        4884 : get_select_query_def(Query *query, deparse_context *context)
    5698             : {
    5699        4884 :     StringInfo  buf = context->buf;
    5700             :     bool        force_colno;
    5701             :     ListCell   *l;
    5702             : 
    5703             :     /* Insert the WITH clause if given */
    5704        4884 :     get_with_clause(query, context);
    5705             : 
    5706             :     /* Subroutines may need to consult the SELECT targetlist and windowClause */
    5707        4884 :     context->targetList = query->targetList;
    5708        4884 :     context->windowClause = query->windowClause;
    5709             : 
    5710             :     /*
    5711             :      * If the Query node has a setOperations tree, then it's the top level of
    5712             :      * a UNION/INTERSECT/EXCEPT query; only the WITH, ORDER BY and LIMIT
    5713             :      * fields are interesting in the top query itself.
    5714             :      */
    5715        4884 :     if (query->setOperations)
    5716             :     {
    5717         152 :         get_setop_query(query->setOperations, query, context);
    5718             :         /* ORDER BY clauses must be simple in this case */
    5719         152 :         force_colno = true;
    5720             :     }
    5721             :     else
    5722             :     {
    5723        4732 :         get_basic_select_query(query, context);
    5724        4732 :         force_colno = false;
    5725             :     }
    5726             : 
    5727             :     /* Add the ORDER BY clause if given */
    5728        4884 :     if (query->sortClause != NIL)
    5729             :     {
    5730         152 :         appendContextKeyword(context, " ORDER BY ",
    5731             :                              -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
    5732         152 :         get_rule_orderby(query->sortClause, query->targetList,
    5733             :                          force_colno, context);
    5734             :     }
    5735             : 
    5736             :     /*
    5737             :      * Add the LIMIT/OFFSET clauses if given. If non-default options, use the
    5738             :      * standard spelling of LIMIT.
    5739             :      */
    5740        4884 :     if (query->limitOffset != NULL)
    5741             :     {
    5742          32 :         appendContextKeyword(context, " OFFSET ",
    5743             :                              -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
    5744          32 :         get_rule_expr(query->limitOffset, context, false);
    5745             :     }
    5746        4884 :     if (query->limitCount != NULL)
    5747             :     {
    5748          70 :         if (query->limitOption == LIMIT_OPTION_WITH_TIES)
    5749             :         {
    5750          32 :             appendContextKeyword(context, " FETCH FIRST ",
    5751             :                                  -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
    5752          32 :             get_rule_expr(query->limitCount, context, false);
    5753          32 :             appendStringInfoString(buf, " ROWS WITH TIES");
    5754             :         }
    5755             :         else
    5756             :         {
    5757          38 :             appendContextKeyword(context, " LIMIT ",
    5758             :                                  -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
    5759          38 :             if (IsA(query->limitCount, Const) &&
    5760          16 :                 ((Const *) query->limitCount)->constisnull)
    5761          16 :                 appendStringInfoString(buf, "ALL");
    5762             :             else
    5763          22 :                 get_rule_expr(query->limitCount, context, false);
    5764             :         }
    5765             :     }
    5766             : 
    5767             :     /* Add FOR [KEY] UPDATE/SHARE clauses if present */
    5768        4884 :     if (query->hasForUpdate)
    5769             :     {
    5770          12 :         foreach(l, query->rowMarks)
    5771             :         {
    5772           6 :             RowMarkClause *rc = (RowMarkClause *) lfirst(l);
    5773             : 
    5774             :             /* don't print implicit clauses */
    5775           6 :             if (rc->pushedDown)
    5776           0 :                 continue;
    5777             : 
    5778           6 :             switch (rc->strength)
    5779             :             {
    5780           0 :                 case LCS_NONE:
    5781             :                     /* we intentionally throw an error for LCS_NONE */
    5782           0 :                     elog(ERROR, "unrecognized LockClauseStrength %d",
    5783             :                          (int) rc->strength);
    5784             :                     break;
    5785           0 :                 case LCS_FORKEYSHARE:
    5786           0 :                     appendContextKeyword(context, " FOR KEY SHARE",
    5787             :                                          -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
    5788           0 :                     break;
    5789           0 :                 case LCS_FORSHARE:
    5790           0 :                     appendContextKeyword(context, " FOR SHARE",
    5791             :                                          -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
    5792           0 :                     break;
    5793           0 :                 case LCS_FORNOKEYUPDATE:
    5794           0 :                     appendContextKeyword(context, " FOR NO KEY UPDATE",
    5795             :                                          -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
    5796           0 :                     break;
    5797           6 :                 case LCS_FORUPDATE:
    5798           6 :                     appendContextKeyword(context, " FOR UPDATE",
    5799             :                                          -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
    5800           6 :                     break;
    5801             :             }
    5802             : 
    5803           6 :             appendStringInfo(buf, " OF %s",
    5804           6 :                              quote_identifier(get_rtable_name(rc->rti,
    5805             :                                                               context)));
    5806           6 :             if (rc->waitPolicy == LockWaitError)
    5807           0 :                 appendStringInfoString(buf, " NOWAIT");
    5808           6 :             else if (rc->waitPolicy == LockWaitSkip)
    5809           0 :                 appendStringInfoString(buf, " SKIP LOCKED");
    5810             :         }
    5811             :     }
    5812        4884 : }
    5813             : 
    5814             : /*
    5815             :  * Detect whether query looks like SELECT ... FROM VALUES(),
    5816             :  * with no need to rename the output columns of the VALUES RTE.
    5817             :  * If so, return the VALUES RTE.  Otherwise return NULL.
    5818             :  */
    5819             : static RangeTblEntry *
    5820        4732 : get_simple_values_rte(Query *query, TupleDesc resultDesc)
    5821             : {
    5822        4732 :     RangeTblEntry *result = NULL;
    5823             :     ListCell   *lc;
    5824             : 
    5825             :     /*
    5826             :      * We want to detect a match even if the Query also contains OLD or NEW
    5827             :      * rule RTEs.  So the idea is to scan the rtable and see if there is only
    5828             :      * one inFromCl RTE that is a VALUES RTE.
    5829             :      */
    5830        5104 :     foreach(lc, query->rtable)
    5831             :     {
    5832        4340 :         RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
    5833             : 
    5834        4340 :         if (rte->rtekind == RTE_VALUES && rte->inFromCl)
    5835             :         {
    5836         228 :             if (result)
    5837        3968 :                 return NULL;    /* multiple VALUES (probably not possible) */
    5838         228 :             result = rte;
    5839             :         }
    5840        4112 :         else if (rte->rtekind == RTE_RELATION && !rte->inFromCl)
    5841         144 :             continue;           /* ignore rule entries */
    5842             :         else
    5843        3968 :             return NULL;        /* something else -> not simple VALUES */
    5844             :     }
    5845             : 
    5846             :     /*
    5847             :      * We don't need to check the targetlist in any great detail, because
    5848             :      * parser/analyze.c will never generate a "bare" VALUES RTE --- they only
    5849             :      * appear inside auto-generated sub-queries with very restricted
    5850             :      * structure.  However, DefineView might have modified the tlist by
    5851             :      * injecting new column aliases, or we might have some other column
    5852             :      * aliases forced by a resultDesc.  We can only simplify if the RTE's
    5853             :      * column names match the names that get_target_list() would select.
    5854             :      */
    5855         764 :     if (result)
    5856             :     {
    5857             :         ListCell   *lcn;
    5858             :         int         colno;
    5859             : 
    5860         228 :         if (list_length(query->targetList) != list_length(result->eref->colnames))
    5861           0 :             return NULL;        /* this probably cannot happen */
    5862         228 :         colno = 0;
    5863         842 :         forboth(lc, query->targetList, lcn, result->eref->colnames)
    5864             :         {
    5865         626 :             TargetEntry *tle = (TargetEntry *) lfirst(lc);
    5866         626 :             char       *cname = strVal(lfirst(lcn));
    5867             :             char       *colname;
    5868             : 
    5869         626 :             if (tle->resjunk)
    5870          12 :                 return NULL;    /* this probably cannot happen */
    5871             : 
    5872             :             /* compute name that get_target_list would use for column */
    5873         626 :             colno++;
    5874         626 :             if (resultDesc && colno <= resultDesc->natts)
    5875          30 :                 colname = NameStr(TupleDescAttr(resultDesc, colno - 1)->attname);
    5876             :             else
    5877         596 :                 colname = tle->resname;
    5878             : 
    5879             :             /* does it match the VALUES RTE? */
    5880         626 :             if (colname == NULL || strcmp(colname, cname) != 0)
    5881          12 :                 return NULL;    /* column name has been changed */
    5882             :         }
    5883             :     }
    5884             : 
    5885         752 :     return result;
    5886             : }
    5887             : 
    5888             : static void
    5889        4732 : get_basic_select_query(Query *query, deparse_context *context)
    5890             : {
    5891        4732 :     StringInfo  buf = context->buf;
    5892             :     RangeTblEntry *values_rte;
    5893             :     char       *sep;
    5894             :     ListCell   *l;
    5895             : 
    5896        4732 :     if (PRETTY_INDENT(context))
    5897             :     {
    5898        4686 :         context->indentLevel += PRETTYINDENT_STD;
    5899        4686 :         appendStringInfoChar(buf, ' ');
    5900             :     }
    5901             : 
    5902             :     /*
    5903             :      * If the query looks like SELECT * FROM (VALUES ...), then print just the
    5904             :      * VALUES part.  This reverses what transformValuesClause() did at parse
    5905             :      * time.
    5906             :      */
    5907        4732 :     values_rte = get_simple_values_rte(query, context->resultDesc);
    5908        4732 :     if (values_rte)
    5909             :     {
    5910         216 :         get_values_def(values_rte->values_lists, context);
    5911         216 :         return;
    5912             :     }
    5913             : 
    5914             :     /*
    5915             :      * Build up the query string - first we say SELECT
    5916             :      */
    5917        4516 :     if (query->isReturn)
    5918          52 :         appendStringInfoString(buf, "RETURN");
    5919             :     else
    5920        4464 :         appendStringInfoString(buf, "SELECT");
    5921             : 
    5922             :     /* Add the DISTINCT clause if given */
    5923        4516 :     if (query->distinctClause != NIL)
    5924             :     {
    5925           0 :         if (query->hasDistinctOn)
    5926             :         {
    5927           0 :             appendStringInfoString(buf, " DISTINCT ON (");
    5928           0 :             sep = "";
    5929           0 :             foreach(l, query->distinctClause)
    5930             :             {
    5931           0 :                 SortGroupClause *srt = (SortGroupClause *) lfirst(l);
    5932             : 
    5933           0 :                 appendStringInfoString(buf, sep);
    5934           0 :                 get_rule_sortgroupclause(srt->tleSortGroupRef, query->targetList,
    5935             :                                          false, context);
    5936           0 :                 sep = ", ";
    5937             :             }
    5938           0 :             appendStringInfoChar(buf, ')');
    5939             :         }
    5940             :         else
    5941           0 :             appendStringInfoString(buf, " DISTINCT");
    5942             :     }
    5943             : 
    5944             :     /* Then we tell what to select (the targetlist) */
    5945        4516 :     get_target_list(query->targetList, context);
    5946             : 
    5947             :     /* Add the FROM clause if needed */
    5948        4516 :     get_from_clause(query, " FROM ", context);
    5949             : 
    5950             :     /* Add the WHERE clause if given */
    5951        4516 :     if (query->jointree->quals != NULL)
    5952             :     {
    5953        1406 :         appendContextKeyword(context, " WHERE ",
    5954             :                              -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
    5955        1406 :         get_rule_expr(query->jointree->quals, context, false);
    5956             :     }
    5957             : 
    5958             :     /* Add the GROUP BY clause if given */
    5959        4516 :     if (query->groupClause != NULL || query->groupingSets != NULL)
    5960             :     {
    5961             :         bool        save_ingroupby;
    5962             : 
    5963         218 :         appendContextKeyword(context, " GROUP BY ",
    5964             :                              -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
    5965         218 :         if (query->groupDistinct)
    5966           0 :             appendStringInfoString(buf, "DISTINCT ");
    5967             : 
    5968         218 :         save_ingroupby = context->inGroupBy;
    5969         218 :         context->inGroupBy = true;
    5970             : 
    5971         218 :         if (query->groupingSets == NIL)
    5972             :         {
    5973         212 :             sep = "";
    5974         482 :             foreach(l, query->groupClause)
    5975             :             {
    5976         270 :                 SortGroupClause *grp = (SortGroupClause *) lfirst(l);
    5977             : 
    5978         270 :                 appendStringInfoString(buf, sep);
    5979         270 :                 get_rule_sortgroupclause(grp->tleSortGroupRef, query->targetList,
    5980             :                                          false, context);
    5981         270 :                 sep = ", ";
    5982             :             }
    5983             :         }
    5984             :         else
    5985             :         {
    5986           6 :             sep = "";
    5987          12 :             foreach(l, query->groupingSets)
    5988             :             {
    5989           6 :                 GroupingSet *grp = lfirst(l);
    5990             : 
    5991           6 :                 appendStringInfoString(buf, sep);
    5992           6 :                 get_rule_groupingset(grp, query->targetList, true, context);
    5993           6 :                 sep = ", ";
    5994             :             }
    5995             :         }
    5996             : 
    5997         218 :         context->inGroupBy = save_ingroupby;
    5998             :     }
    5999             : 
    6000             :     /* Add the HAVING clause if given */
    6001        4516 :     if (query->havingQual != NULL)
    6002             :     {
    6003          10 :         appendContextKeyword(context, " HAVING ",
    6004             :                              -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
    6005          10 :         get_rule_expr(query->havingQual, context, false);
    6006             :     }
    6007             : 
    6008             :     /* Add the WINDOW clause if needed */
    6009        4516 :     if (query->windowClause != NIL)
    6010          42 :         get_rule_windowclause(query, context);
    6011             : }
    6012             : 
    6013             : /* ----------
    6014             :  * get_target_list          - Parse back a SELECT target list
    6015             :  *
    6016             :  * This is also used for RETURNING lists in INSERT/UPDATE/DELETE/MERGE.
    6017             :  * ----------
    6018             :  */
    6019             : static void
    6020        4638 : get_target_list(List *targetList, deparse_context *context)
    6021             : {
    6022        4638 :     StringInfo  buf = context->buf;
    6023             :     StringInfoData targetbuf;
    6024        4638 :     bool        last_was_multiline = false;
    6025             :     char       *sep;
    6026             :     int         colno;
    6027             :     ListCell   *l;
    6028             : 
    6029             :     /* we use targetbuf to hold each TLE's text temporarily */
    6030        4638 :     initStringInfo(&targetbuf);
    6031             : 
    6032        4638 :     sep = " ";
    6033        4638 :     colno = 0;
    6034       23748 :     foreach(l, targetList)
    6035             :     {
    6036       19110 :         TargetEntry *tle = (TargetEntry *) lfirst(l);
    6037             :         char       *colname;
    6038             :         char       *attname;
    6039             : 
    6040       19110 :         if (tle->resjunk)
    6041          34 :             continue;           /* ignore junk entries */
    6042             : 
    6043       19076 :         appendStringInfoString(buf, sep);
    6044       19076 :         sep = ", ";
    6045       19076 :         colno++;
    6046             : 
    6047             :         /*
    6048             :          * Put the new field text into targetbuf so we can decide after we've
    6049             :          * got it whether or not it needs to go on a new line.
    6050             :          */
    6051       19076 :         resetStringInfo(&targetbuf);
    6052       19076 :         context->buf = &targetbuf;
    6053             : 
    6054             :         /*
    6055             :          * We special-case Var nodes rather than using get_rule_expr. This is
    6056             :          * needed because get_rule_expr will display a whole-row Var as
    6057             :          * "foo.*", which is the preferred notation in most contexts, but at
    6058             :          * the top level of a SELECT list it's not right (the parser will
    6059             :          * expand that notation into multiple columns, yielding behavior
    6060             :          * different from a whole-row Var).  We need to call get_variable
    6061             :          * directly so that we can tell it to do the right thing, and so that
    6062             :          * we can get the attribute name which is the default AS label.
    6063             :          */
    6064       19076 :         if (tle->expr && (IsA(tle->expr, Var)))
    6065             :         {
    6066       14806 :             attname = get_variable((Var *) tle->expr, 0, true, context);
    6067             :         }
    6068             :         else
    6069             :         {
    6070        4270 :             get_rule_expr((Node *) tle->expr, context, true);
    6071             : 
    6072             :             /*
    6073             :              * When colNamesVisible is true, we should always show the
    6074             :              * assigned column name explicitly.  Otherwise, show it only if
    6075             :              * it's not FigureColname's fallback.
    6076             :              */
    6077        4270 :             attname = context->colNamesVisible ? NULL : "?column?";
    6078             :         }
    6079             : 
    6080             :         /*
    6081             :          * Figure out what the result column should be called.  In the context
    6082             :          * of a view, use the view's tuple descriptor (so as to pick up the
    6083             :          * effects of any column RENAME that's been done on the view).
    6084             :          * Otherwise, just use what we can find in the TLE.
    6085             :          */
    6086       19076 :         if (context->resultDesc && colno <= context->resultDesc->natts)
    6087       17536 :             colname = NameStr(TupleDescAttr(context->resultDesc,
    6088             :                                             colno - 1)->attname);
    6089             :         else
    6090        1540 :             colname = tle->resname;
    6091             : 
    6092             :         /* Show AS unless the column's name is correct as-is */
    6093       19076 :         if (colname)            /* resname could be NULL */
    6094             :         {
    6095       19024 :             if (attname == NULL || strcmp(attname, colname) != 0)
    6096        6216 :                 appendStringInfo(&targetbuf, " AS %s", quote_identifier(colname));
    6097             :         }
    6098             : 
    6099             :         /* Restore context's output buffer */
    6100       19076 :         context->buf = buf;
    6101             : 
    6102             :         /* Consider line-wrapping if enabled */
    6103       19076 :         if (PRETTY_INDENT(context) && context->wrapColumn >= 0)
    6104             :         {
    6105             :             int         leading_nl_pos;
    6106             : 
    6107             :             /* Does the new field start with a new line? */
    6108       19030 :             if (targetbuf.len > 0 && targetbuf.data[0] == '\n')
    6109         462 :                 leading_nl_pos = 0;
    6110             :             else
    6111       18568 :                 leading_nl_pos = -1;
    6112             : 
    6113             :             /* If so, we shouldn't add anything */
    6114       19030 :             if (leading_nl_pos >= 0)
    6115             :             {
    6116             :                 /* instead, remove any trailing spaces currently in buf */
    6117         462 :                 removeStringInfoSpaces(buf);
    6118             :             }
    6119             :             else
    6120             :             {
    6121             :                 char       *trailing_nl;
    6122             : 
    6123             :                 /* Locate the start of the current line in the output buffer */
    6124       18568 :                 trailing_nl = strrchr(buf->data, '\n');
    6125       18568 :                 if (trailing_nl == NULL)
    6126        5660 :                     trailing_nl = buf->data;
    6127             :                 else
    6128       12908 :                     trailing_nl++;
    6129             : 
    6130             :                 /*
    6131             :                  * Add a newline, plus some indentation, if the new field is
    6132             :                  * not the first and either the new field would cause an
    6133             :                  * overflow or the last field used more than one line.
    6134             :                  */
    6135       18568 :                 if (colno > 1 &&
    6136       13992 :                     ((strlen(trailing_nl) + targetbuf.len > context->wrapColumn) ||
    6137             :                      last_was_multiline))
    6138       13992 :                     appendContextKeyword(context, "", -PRETTYINDENT_STD,
    6139             :                                          PRETTYINDENT_STD, PRETTYINDENT_VAR);
    6140             :             }
    6141             : 
    6142             :             /* Remember this field's multiline status for next iteration */
    6143       19030 :             last_was_multiline =
    6144       19030 :                 (strchr(targetbuf.data + leading_nl_pos + 1, '\n') != NULL);
    6145             :         }
    6146             : 
    6147             :         /* Add the new field */
    6148       19076 :         appendBinaryStringInfo(buf, targetbuf.data, targetbuf.len);
    6149             :     }
    6150             : 
    6151             :     /* clean up */
    6152        4638 :     pfree(targetbuf.data);
    6153        4638 : }
    6154             : 
    6155             : static void
    6156         720 : get_setop_query(Node *setOp, Query *query, deparse_context *context)
    6157             : {
    6158         720 :     StringInfo  buf = context->buf;
    6159             :     bool        need_paren;
    6160             : 
    6161             :     /* Guard against excessively long or deeply-nested queries */
    6162         720 :     CHECK_FOR_INTERRUPTS();
    6163         720 :     check_stack_depth();
    6164             : 
    6165         720 :     if (IsA(setOp, RangeTblRef))
    6166             :     {
    6167         436 :         RangeTblRef *rtr = (RangeTblRef *) setOp;
    6168         436 :         RangeTblEntry *rte = rt_fetch(rtr->rtindex, query->rtable);
    6169         436 :         Query      *subquery = rte->subquery;
    6170             : 
    6171             :         Assert(subquery != NULL);
    6172             :         Assert(subquery->setOperations == NULL);
    6173             :         /* Need parens if WITH, ORDER BY, FOR UPDATE, or LIMIT; see gram.y */
    6174        1308 :         need_paren = (subquery->cteList ||
    6175         436 :                       subquery->sortClause ||
    6176         436 :                       subquery->rowMarks ||
    6177        1308 :                       subquery->limitOffset ||
    6178         436 :                       subquery->limitCount);
    6179         436 :         if (need_paren)
    6180           0 :             appendStringInfoChar(buf, '(');
    6181         436 :         get_query_def(subquery, buf, context->namespaces,
    6182         436 :                       context->resultDesc, context->colNamesVisible,
    6183             :                       context->prettyFlags, context->wrapColumn,
    6184             :                       context->indentLevel);
    6185         436 :         if (need_paren)
    6186           0 :             appendStringInfoChar(buf, ')');
    6187             :     }
    6188         284 :     else if (IsA(setOp, SetOperationStmt))
    6189             :     {
    6190         284 :         SetOperationStmt *op = (SetOperationStmt *) setOp;
    6191             :         int         subindent;
    6192             :         bool        save_colnamesvisible;
    6193             : 
    6194             :         /*
    6195             :          * We force parens when nesting two SetOperationStmts, except when the
    6196             :          * lefthand input is another setop of the same kind.  Syntactically,
    6197             :          * we could omit parens in rather more cases, but it seems best to use
    6198             :          * parens to flag cases where the setop operator changes.  If we use
    6199             :          * parens, we also increase the indentation level for the child query.
    6200             :          *
    6201             :          * There are some cases in which parens are needed around a leaf query
    6202             :          * too, but those are more easily handled at the next level down (see
    6203             :          * code above).
    6204             :          */
    6205         284 :         if (IsA(op->larg, SetOperationStmt))
    6206             :         {
    6207         132 :             SetOperationStmt *lop = (SetOperationStmt *) op->larg;
    6208             : 
    6209         132 :             if (op->op == lop->op && op->all == lop->all)
    6210         132 :                 need_paren = false;
    6211             :             else
    6212           0 :                 need_paren = true;
    6213             :         }
    6214             :         else
    6215         152 :             need_paren = false;
    6216             : 
    6217         284 :         if (need_paren)
    6218             :         {
    6219           0 :             appendStringInfoChar(buf, '(');
    6220           0 :             subindent = PRETTYINDENT_STD;
    6221           0 :             appendContextKeyword(context, "", subindent, 0, 0);
    6222             :         }
    6223             :         else
    6224         284 :             subindent = 0;
    6225             : 
    6226         284 :         get_setop_query(op->larg, query, context);
    6227             : 
    6228         284 :         if (need_paren)
    6229           0 :             appendContextKeyword(context, ") ", -subindent, 0, 0);
    6230         284 :         else if (PRETTY_INDENT(context))
    6231         284 :             appendContextKeyword(context, "", -subindent, 0, 0);
    6232             :         else
    6233           0 :             appendStringInfoChar(buf, ' ');
    6234             : 
    6235         284 :         switch (op->op)
    6236             :         {
    6237         284 :             case SETOP_UNION:
    6238         284 :                 appendStringInfoString(buf, "UNION ");
    6239         284 :                 break;
    6240           0 :             case SETOP_INTERSECT:
    6241           0 :                 appendStringInfoString(buf, "INTERSECT ");
    6242           0 :                 break;
    6243           0 :             case SETOP_EXCEPT:
    6244           0 :                 appendStringInfoString(buf, "EXCEPT ");
    6245           0 :                 break;
    6246           0 :             default:
    6247           0 :                 elog(ERROR, "unrecognized set op: %d",
    6248             :                      (int) op->op);
    6249             :         }
    6250         284 :         if (op->all)
    6251         272 :             appendStringInfoString(buf, "ALL ");
    6252             : 
    6253             :         /* Always parenthesize if RHS is another setop */
    6254         284 :         need_paren = IsA(op->rarg, SetOperationStmt);
    6255             : 
    6256             :         /*
    6257             :          * The indentation code here is deliberately a bit different from that
    6258             :          * for the lefthand input, because we want the line breaks in
    6259             :          * different places.
    6260             :          */
    6261         284 :         if (need_paren)
    6262             :         {
    6263           0 :             appendStringInfoChar(buf, '(');
    6264           0 :             subindent = PRETTYINDENT_STD;
    6265             :         }
    6266             :         else
    6267         284 :             subindent = 0;
    6268         284 :         appendContextKeyword(context, "", subindent, 0, 0);
    6269             : 
    6270             :         /*
    6271             :          * The output column names of the RHS sub-select don't matter.
    6272             :          */
    6273         284 :         save_colnamesvisible = context->colNamesVisible;
    6274         284 :         context->colNamesVisible = false;
    6275             : 
    6276         284 :         get_setop_query(op->rarg, query, context);
    6277             : 
    6278         284 :         context->colNamesVisible = save_colnamesvisible;
    6279             : 
    6280         284 :         if (PRETTY_INDENT(context))
    6281         284 :             context->indentLevel -= subindent;
    6282         284 :         if (need_paren)
    6283           0 :             appendContextKeyword(context, ")", 0, 0, 0);
    6284             :     }
    6285             :     else
    6286             :     {
    6287           0 :         elog(ERROR, "unrecognized node type: %d",
    6288             :              (int) nodeTag(setOp));
    6289             :     }
    6290         720 : }
    6291             : 
    6292             : /*
    6293             :  * Display a sort/group clause.
    6294             :  *
    6295             :  * Also returns the expression tree, so caller need not find it again.
    6296             :  */
    6297             : static Node *
    6298         636 : get_rule_sortgroupclause(Index ref, List *tlist, bool force_colno,
    6299             :                          deparse_context *context)
    6300             : {
    6301         636 :     StringInfo  buf = context->buf;
    6302             :     TargetEntry *tle;
    6303             :     Node       *expr;
    6304             : 
    6305         636 :     tle = get_sortgroupref_tle(ref, tlist);
    6306         636 :     expr = (Node *) tle->expr;
    6307             : 
    6308             :     /*
    6309             :      * Use column-number form if requested by caller.  Otherwise, if
    6310             :      * expression is a constant, force it to be dumped with an explicit cast
    6311             :      * as decoration --- this is because a simple integer constant is
    6312             :      * ambiguous (and will be misinterpreted by findTargetlistEntrySQL92()) if
    6313             :      * we dump it without any decoration.  Similarly, if it's just a Var,
    6314             :      * there is risk of misinterpretation if the column name is reassigned in
    6315             :      * the SELECT list, so we may need to force table qualification.  And, if
    6316             :      * it's anything more complex than a simple Var, then force extra parens
    6317             :      * around it, to ensure it can't be misinterpreted as a cube() or rollup()
    6318             :      * construct.
    6319             :      */
    6320         636 :     if (force_colno)
    6321             :     {
    6322             :         Assert(!tle->resjunk);
    6323           0 :         appendStringInfo(buf, "%d", tle->resno);
    6324             :     }
    6325         636 :     else if (!expr)
    6326             :          /* do nothing, probably can't happen */ ;
    6327         636 :     else if (IsA(expr, Const))
    6328           0 :         get_const_expr((Const *) expr, context, 1);
    6329         636 :     else if (IsA(expr, Var))
    6330             :     {
    6331             :         /* Tell get_variable to check for name conflict */
    6332         608 :         bool        save_varinorderby = context->varInOrderBy;
    6333             : 
    6334         608 :         context->varInOrderBy = true;
    6335         608 :         (void) get_variable((Var *) expr, 0, false, context);
    6336         608 :         context->varInOrderBy = save_varinorderby;
    6337             :     }
    6338             :     else
    6339             :     {
    6340             :         /*
    6341             :          * We must force parens for function-like expressions even if
    6342             :          * PRETTY_PAREN is off, since those are the ones in danger of
    6343             :          * misparsing. For other expressions we need to force them only if
    6344             :          * PRETTY_PAREN is on, since otherwise the expression will output them
    6345             :          * itself. (We can't skip the parens.)
    6346             :          */
    6347          56 :         bool        need_paren = (PRETTY_PAREN(context)
    6348          28 :                                   || IsA(expr, FuncExpr)
    6349          24 :                                   || IsA(expr, Aggref)
    6350          24 :                                   || IsA(expr, WindowFunc)
    6351          56 :                                   || IsA(expr, JsonConstructorExpr));
    6352             : 
    6353          28 :         if (need_paren)
    6354           4 :             appendStringInfoChar(context->buf, '(');
    6355          28 :         get_rule_expr(expr, context, true);
    6356          28 :         if (need_paren)
    6357           4 :             appendStringInfoChar(context->buf, ')');
    6358             :     }
    6359             : 
    6360         636 :     return expr;
    6361             : }
    6362             : 
    6363             : /*
    6364             :  * Display a GroupingSet
    6365             :  */
    6366             : static void
    6367          18 : get_rule_groupingset(GroupingSet *gset, List *targetlist,
    6368             :                      bool omit_parens, deparse_context *context)
    6369             : {
    6370             :     ListCell   *l;
    6371          18 :     StringInfo  buf = context->buf;
    6372          18 :     bool        omit_child_parens = true;
    6373          18 :     char       *sep = "";
    6374             : 
    6375          18 :     switch (gset->kind)
    6376             :     {
    6377           0 :         case GROUPING_SET_EMPTY:
    6378           0 :             appendStringInfoString(buf, "()");
    6379           0 :             return;
    6380             : 
    6381          12 :         case GROUPING_SET_SIMPLE:
    6382             :             {
    6383          12 :                 if (!omit_parens || list_length(gset->content) != 1)
    6384          12 :                     appendStringInfoChar(buf, '(');
    6385             : 
    6386          42 :                 foreach(l, gset->content)
    6387             :                 {
    6388          30 :                     Index       ref = lfirst_int(l);
    6389             : 
    6390          30 :                     appendStringInfoString(buf, sep);
    6391          30 :                     get_rule_sortgroupclause(ref, targetlist,
    6392             :                                              false, context);
    6393          30 :                     sep = ", ";
    6394             :                 }
    6395             : 
    6396          12 :                 if (!omit_parens || list_length(gset->content) != 1)
    6397          12 :                     appendStringInfoChar(buf, ')');
    6398             :             }
    6399          12 :             return;
    6400             : 
    6401           6 :         case GROUPING_SET_ROLLUP:
    6402           6 :             appendStringInfoString(buf, "ROLLUP(");
    6403           6 :             break;
    6404           0 :         case GROUPING_SET_CUBE:
    6405           0 :             appendStringInfoString(buf, "CUBE(");
    6406           0 :             break;
    6407           0 :         case GROUPING_SET_SETS:
    6408           0 :             appendStringInfoString(buf, "GROUPING SETS (");
    6409           0 :             omit_child_parens = false;
    6410           0 :             break;
    6411             :     }
    6412             : 
    6413          18 :     foreach(l, gset->content)
    6414             :     {
    6415          12 :         appendStringInfoString(buf, sep);
    6416          12 :         get_rule_groupingset(lfirst(l), targetlist, omit_child_parens, context);
    6417          12 :         sep = ", ";
    6418             :     }
    6419             : 
    6420           6 :     appendStringInfoChar(buf, ')');
    6421             : }
    6422             : 
    6423             : /*
    6424             :  * Display an ORDER BY list.
    6425             :  */
    6426             : static void
    6427         304 : get_rule_orderby(List *orderList, List *targetList,
    6428             :                  bool force_colno, deparse_context *context)
    6429             : {
    6430         304 :     StringInfo  buf = context->buf;
    6431             :     const char *sep;
    6432             :     ListCell   *l;
    6433             : 
    6434         304 :     sep = "";
    6435         640 :     foreach(l, orderList)
    6436             :     {
    6437         336 :         SortGroupClause *srt = (SortGroupClause *) lfirst(l);
    6438             :         Node       *sortexpr;
    6439             :         Oid         sortcoltype;
    6440             :         TypeCacheEntry *typentry;
    6441             : 
    6442         336 :         appendStringInfoString(buf, sep);
    6443         336 :         sortexpr = get_rule_sortgroupclause(srt->tleSortGroupRef, targetList,
    6444             :                                             force_colno, context);
    6445         336 :         sortcoltype = exprType(sortexpr);
    6446             :         /* See whether operator is default < or > for datatype */
    6447         336 :         typentry = lookup_type_cache(sortcoltype,
    6448             :                                      TYPECACHE_LT_OPR | TYPECACHE_GT_OPR);
    6449         336 :         if (srt->sortop == typentry->lt_opr)
    6450             :         {
    6451             :             /* ASC is default, so emit nothing for it */
    6452         308 :             if (srt->nulls_first)
    6453           0 :                 appendStringInfoString(buf, " NULLS FIRST");
    6454             :         }
    6455          28 :         else if (srt->sortop == typentry->gt_opr)
    6456             :         {
    6457          10 :             appendStringInfoString(buf, " DESC");
    6458             :             /* DESC defaults to NULLS FIRST */
    6459          10 :             if (!srt->nulls_first)
    6460           2 :                 appendStringInfoString(buf, " NULLS LAST");
    6461             :         }
    6462             :         else
    6463             :         {
    6464          18 :             appendStringInfo(buf, " USING %s",
    6465             :                              generate_operator_name(srt->sortop,
    6466             :                                                     sortcoltype,
    6467             :                                                     sortcoltype));
    6468             :             /* be specific to eliminate ambiguity */
    6469          18 :             if (srt->nulls_first)
    6470           0 :                 appendStringInfoString(buf, " NULLS FIRST");
    6471             :             else
    6472          18 :                 appendStringInfoString(buf, " NULLS LAST");
    6473             :         }
    6474         336 :         sep = ", ";
    6475             :     }
    6476         304 : }
    6477             : 
    6478             : /*
    6479             :  * Display a WINDOW clause.
    6480             :  *
    6481             :  * Note that the windowClause list might contain only anonymous window
    6482             :  * specifications, in which case we should print nothing here.
    6483             :  */
    6484             : static void
    6485          42 : get_rule_windowclause(Query *query, deparse_context *context)
    6486             : {
    6487          42 :     StringInfo  buf = context->buf;
    6488             :     const char *sep;
    6489             :     ListCell   *l;
    6490             : 
    6491          42 :     sep = NULL;
    6492          84 :     foreach(l, query->windowClause)
    6493             :     {
    6494          42 :         WindowClause *wc = (WindowClause *) lfirst(l);
    6495             : 
    6496          42 :         if (wc->name == NULL)
    6497          42 :             continue;           /* ignore anonymous windows */
    6498             : 
    6499           0 :         if (sep == NULL)
    6500           0 :             appendContextKeyword(context, " WINDOW ",
    6501             :                                  -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
    6502             :         else
    6503           0 :             appendStringInfoString(buf, sep);
    6504             : 
    6505           0 :         appendStringInfo(buf, "%s AS ", quote_identifier(wc->name));
    6506             : 
    6507           0 :         get_rule_windowspec(wc, query->targetList, context);
    6508             : 
    6509           0 :         sep = ", ";
    6510             :     }
    6511          42 : }
    6512             : 
    6513             : /*
    6514             :  * Display a window definition
    6515             :  */
    6516             : static void
    6517          42 : get_rule_windowspec(WindowClause *wc, List *targetList,
    6518             :                     deparse_context *context)
    6519             : {
    6520          42 :     StringInfo  buf = context->buf;
    6521          42 :     bool        needspace = false;
    6522             :     const char *sep;
    6523             :     ListCell   *l;
    6524             : 
    6525          42 :     appendStringInfoChar(buf, '(');
    6526          42 :     if (wc->refname)
    6527             :     {
    6528           0 :         appendStringInfoString(buf, quote_identifier(wc->refname));
    6529           0 :         needspace = true;
    6530             :     }
    6531             :     /* partition clauses are always inherited, so only print if no refname */
    6532          42 :     if (wc->partitionClause && !wc->refname)
    6533             :     {
    6534           0 :         if (needspace)
    6535           0 :             appendStringInfoChar(buf, ' ');
    6536           0 :         appendStringInfoString(buf, "PARTITION BY ");
    6537           0 :         sep = "";
    6538           0 :         foreach(l, wc->partitionClause)
    6539             :         {
    6540           0 :             SortGroupClause *grp = (SortGroupClause *) lfirst(l);
    6541             : 
    6542           0 :             appendStringInfoString(buf, sep);
    6543           0 :             get_rule_sortgroupclause(grp->tleSortGroupRef, targetList,
    6544             :                                      false, context);
    6545           0 :             sep = ", ";
    6546             :         }
    6547           0 :         needspace = true;
    6548             :     }
    6549             :     /* print ordering clause only if not inherited */
    6550          42 :     if (wc->orderClause && !wc->copiedOrder)
    6551             :     {
    6552          42 :         if (needspace)
    6553           0 :             appendStringInfoChar(buf, ' ');
    6554          42 :         appendStringInfoString(buf, "ORDER BY ");
    6555          42 :         get_rule_orderby(wc->orderClause, targetList, false, context);
    6556          42 :         needspace = true;
    6557             :     }
    6558             :     /* framing clause is never inherited, so print unless it's default */
    6559          42 :     if (wc->frameOptions & FRAMEOPTION_NONDEFAULT)
    6560             :     {
    6561          42 :         if (needspace)
    6562          42 :             appendStringInfoChar(buf, ' ');
    6563          42 :         if (wc->frameOptions & FRAMEOPTION_RANGE)
    6564           6 :             appendStringInfoString(buf, "RANGE ");
    6565          36 :         else if (wc->frameOptions & FRAMEOPTION_ROWS)
    6566          30 :             appendStringInfoString(buf, "ROWS ");
    6567           6 :         else if (wc->frameOptions & FRAMEOPTION_GROUPS)
    6568           6 :             appendStringInfoString(buf, "GROUPS ");
    6569             :         else
    6570             :             Assert(false);
    6571          42 :         if (wc->frameOptions & FRAMEOPTION_BETWEEN)
    6572          42 :             appendStringInfoString(buf, "BETWEEN ");
    6573          42 :         if (wc->frameOptions & FRAMEOPTION_START_UNBOUNDED_PRECEDING)
    6574           0 :             appendStringInfoString(buf, "UNBOUNDED PRECEDING ");
    6575          42 :         else if (wc->frameOptions & FRAMEOPTION_START_CURRENT_ROW)
    6576           0 :             appendStringInfoString(buf, "CURRENT ROW ");
    6577          42 :         else if (wc->frameOptions & FRAMEOPTION_START_OFFSET)
    6578             :         {
    6579          42 :             get_rule_expr(wc->startOffset, context, false);
    6580          42 :             if (wc->frameOptions & FRAMEOPTION_START_OFFSET_PRECEDING)
    6581          42 :                 appendStringInfoString(buf, " PRECEDING ");
    6582           0 :             else if (wc->frameOptions & FRAMEOPTION_START_OFFSET_FOLLOWING)
    6583           0 :                 appendStringInfoString(buf, " FOLLOWING ");
    6584             :             else
    6585             :                 Assert(false);
    6586             :         }
    6587             :         else
    6588             :             Assert(false);
    6589          42 :         if (wc->frameOptions & FRAMEOPTION_BETWEEN)
    6590             :         {
    6591          42 :             appendStringInfoString(buf, "AND ");
    6592          42 :             if (wc->frameOptions & FRAMEOPTION_END_UNBOUNDED_FOLLOWING)
    6593           0 :                 appendStringInfoString(buf, "UNBOUNDED FOLLOWING ");
    6594          42 :             else if (wc->frameOptions & FRAMEOPTION_END_CURRENT_ROW)
    6595           0 :                 appendStringInfoString(buf, "CURRENT ROW ");
    6596          42 :             else if (wc->frameOptions & FRAMEOPTION_END_OFFSET)
    6597             :             {
    6598          42 :                 get_rule_expr(wc->endOffset, context, false);
    6599          42 :                 if (wc->frameOptions & FRAMEOPTION_END_OFFSET_PRECEDING)
    6600           0 :                     appendStringInfoString(buf, " PRECEDING ");
    6601          42 :                 else if (wc->frameOptions & FRAMEOPTION_END_OFFSET_FOLLOWING)
    6602          42 :                     appendStringInfoString(buf, " FOLLOWING ");
    6603             :                 else
    6604             :                     Assert(false);
    6605             :             }
    6606             :             else
    6607             :                 Assert(false);
    6608             :         }
    6609          42 :         if (wc->frameOptions & FRAMEOPTION_EXCLUDE_CURRENT_ROW)
    6610           6 :             appendStringInfoString(buf, "EXCLUDE CURRENT ROW ");
    6611          36 :         else if (wc->frameOptions & FRAMEOPTION_EXCLUDE_GROUP)
    6612           6 :             appendStringInfoString(buf, "EXCLUDE GROUP ");
    6613          30 :         else if (wc->frameOptions & FRAMEOPTION_EXCLUDE_TIES)
    6614           6 :             appendStringInfoString(buf, "EXCLUDE TIES ");
    6615             :         /* we will now have a trailing space; remove it */
    6616          42 :         buf->len--;
    6617             :     }
    6618          42 :     appendStringInfoChar(buf, ')');
    6619          42 : }
    6620             : 
    6621             : /* ----------
    6622             :  * get_insert_query_def         - Parse back an INSERT parsetree
    6623             :  * ----------
    6624             :  */
    6625             : static void
    6626         340 : get_insert_query_def(Query *query, deparse_context *context)
    6627             : {
    6628         340 :     StringInfo  buf = context->buf;
    6629         340 :     RangeTblEntry *select_rte = NULL;
    6630         340 :     RangeTblEntry *values_rte = NULL;
    6631             :     RangeTblEntry *rte;
    6632             :     char       *sep;
    6633             :     ListCell   *l;
    6634             :     List       *strippedexprs;
    6635             : 
    6636             :     /* Insert the WITH clause if given */
    6637         340 :     get_with_clause(query, context);
    6638             : 
    6639             :     /*
    6640             :      * If it's an INSERT ... SELECT or multi-row VALUES, there will be a
    6641             :      * single RTE for the SELECT or VALUES.  Plain VALUES has neither.
    6642             :      */
    6643        1322 :     foreach(l, query->rtable)
    6644             :     {
    6645         982 :         rte = (RangeTblEntry *) lfirst(l);
    6646             : 
    6647         982 :         if (rte->rtekind == RTE_SUBQUERY)
    6648             :         {
    6649          50 :             if (select_rte)
    6650           0 :                 elog(ERROR, "too many subquery RTEs in INSERT");
    6651          50 :             select_rte = rte;
    6652             :         }
    6653             : 
    6654         982 :         if (rte->rtekind == RTE_VALUES)
    6655             :         {
    6656          44 :             if (values_rte)
    6657           0 :                 elog(ERROR, "too many values RTEs in INSERT");
    6658          44 :             values_rte = rte;
    6659             :         }
    6660             :     }
    6661         340 :     if (select_rte && values_rte)
    6662           0 :         elog(ERROR, "both subquery and values RTEs in INSERT");
    6663             : 
    6664             :     /*
    6665             :      * Start the query with INSERT INTO relname
    6666             :      */
    6667         340 :     rte = rt_fetch(query->resultRelation, query->rtable);
    6668             :     Assert(rte->rtekind == RTE_RELATION);
    6669             : 
    6670         340 :     if (PRETTY_INDENT(context))
    6671             :     {
    6672         340 :         context->indentLevel += PRETTYINDENT_STD;
    6673         340 :         appendStringInfoChar(buf, ' ');
    6674             :     }
    6675         340 :     appendStringInfo(buf, "INSERT INTO %s",
    6676             :                      generate_relation_name(rte->relid, NIL));
    6677             : 
    6678             :     /* Print the relation alias, if needed; INSERT requires explicit AS */
    6679         340 :     get_rte_alias(rte, query->resultRelation, true, context);
    6680             : 
    6681             :     /* always want a space here */
    6682         340 :     appendStringInfoChar(buf, ' ');
    6683             : 
    6684             :     /*
    6685             :      * Add the insert-column-names list.  Any indirection decoration needed on
    6686             :      * the column names can be inferred from the top targetlist.
    6687             :      */
    6688         340 :     strippedexprs = NIL;
    6689         340 :     sep = "";
    6690         340 :     if (query->targetList)
    6691         340 :         appendStringInfoChar(buf, '(');
    6692        1242 :     foreach(l, query->targetList)
    6693             :     {
    6694         902 :         TargetEntry *tle = (TargetEntry *) lfirst(l);
    6695             : 
    6696         902 :         if (tle->resjunk)
    6697           0 :             continue;           /* ignore junk entries */
    6698             : 
    6699         902 :         appendStringInfoString(buf, sep);
    6700         902 :         sep = ", ";
    6701             : 
    6702             :         /*
    6703             :          * Put out name of target column; look in the catalogs, not at
    6704             :          * tle->resname, since resname will fail to track RENAME.
    6705             :          */
    6706         902 :         appendStringInfoString(buf,
    6707         902 :                                quote_identifier(get_attname(rte->relid,
    6708         902 :                                                             tle->resno,
    6709             :                                                             false)));
    6710             : 
    6711             :         /*
    6712             :          * Print any indirection needed (subfields or subscripts), and strip
    6713             :          * off the top-level nodes representing the indirection assignments.
    6714             :          * Add the stripped expressions to strippedexprs.  (If it's a
    6715             :          * single-VALUES statement, the stripped expressions are the VALUES to
    6716             :          * print below.  Otherwise they're just Vars and not really
    6717             :          * interesting.)
    6718             :          */
    6719         902 :         strippedexprs = lappend(strippedexprs,
    6720         902 :                                 processIndirection((Node *) tle->expr,
    6721             :                                                    context));
    6722             :     }
    6723         340 :     if (query->targetList)
    6724         340 :         appendStringInfoString(buf, ") ");
    6725             : 
    6726         340 :     if (query->override)
    6727             :     {
    6728           0 :         if (query->override == OVERRIDING_SYSTEM_VALUE)
    6729           0 :             appendStringInfoString(buf, "OVERRIDING SYSTEM VALUE ");
    6730           0 :         else if (query->override == OVERRIDING_USER_VALUE)
    6731           0 :             appendStringInfoString(buf, "OVERRIDING USER VALUE ");
    6732             :     }
    6733             : 
    6734         340 :     if (select_rte)
    6735             :     {
    6736             :         /* Add the SELECT */
    6737          50 :         get_query_def(select_rte->subquery, buf, context->namespaces, NULL,
    6738             :                       false,
    6739             :                       context->prettyFlags, context->wrapColumn,
    6740             :                       context->indentLevel);
    6741             :     }
    6742         290 :     else if (values_rte)
    6743             :     {
    6744             :         /* Add the multi-VALUES expression lists */
    6745          44 :         get_values_def(values_rte->values_lists, context);
    6746             :     }
    6747         246 :     else if (strippedexprs)
    6748             :     {
    6749             :         /* Add the single-VALUES expression list */
    6750         246 :         appendContextKeyword(context, "VALUES (",
    6751             :                              -PRETTYINDENT_STD, PRETTYINDENT_STD, 2);
    6752         246 :         get_rule_list_toplevel(strippedexprs, context, false);
    6753         246 :         appendStringInfoChar(buf, ')');
    6754             :     }
    6755             :     else
    6756             :     {
    6757             :         /* No expressions, so it must be DEFAULT VALUES */
    6758           0 :         appendStringInfoString(buf, "DEFAULT VALUES");
    6759             :     }
    6760             : 
    6761             :     /* Add ON CONFLICT if present */
    6762         340 :     if (query->onConflict)
    6763             :     {
    6764          30 :         OnConflictExpr *confl = query->onConflict;
    6765             : 
    6766          30 :         appendStringInfoString(buf, " ON CONFLICT");
    6767             : 
    6768          30 :         if (confl->arbiterElems)
    6769             :         {
    6770             :             /* Add the single-VALUES expression list */
    6771          24 :             appendStringInfoChar(buf, '(');
    6772          24 :             get_rule_expr((Node *) confl->arbiterElems, context, false);
    6773          24 :             appendStringInfoChar(buf, ')');
    6774             : 
    6775             :             /* Add a WHERE clause (for partial indexes) if given */
    6776          24 :             if (confl->arbiterWhere != NULL)
    6777             :             {
    6778             :                 bool        save_varprefix;
    6779             : 
    6780             :                 /*
    6781             :                  * Force non-prefixing of Vars, since parser assumes that they
    6782             :                  * belong to target relation.  WHERE clause does not use
    6783             :                  * InferenceElem, so this is separately required.
    6784             :                  */
    6785          12 :                 save_varprefix = context->varprefix;
    6786          12 :                 context->varprefix = false;
    6787             : 
    6788          12 :                 appendContextKeyword(context, " WHERE ",
    6789             :                                      -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
    6790          12 :                 get_rule_expr(confl->arbiterWhere, context, false);
    6791             : 
    6792          12 :                 context->varprefix = save_varprefix;
    6793             :             }
    6794             :         }
    6795           6 :         else if (OidIsValid(confl->constraint))
    6796             :         {
    6797           0 :             char       *constraint = get_constraint_name(confl->constraint);
    6798             : 
    6799           0 :             if (!constraint)
    6800           0 :                 elog(ERROR, "cache lookup failed for constraint %u",
    6801             :                      confl->constraint);
    6802           0 :             appendStringInfo(buf, " ON CONSTRAINT %s",
    6803             :                              quote_identifier(constraint));
    6804             :         }
    6805             : 
    6806          30 :         if (confl->action == ONCONFLICT_NOTHING)
    6807             :         {
    6808          18 :             appendStringInfoString(buf, " DO NOTHING");
    6809             :         }
    6810             :         else
    6811             :         {
    6812          12 :             appendStringInfoString(buf, " DO UPDATE SET ");
    6813             :             /* Deparse targetlist */
    6814          12 :             get_update_query_targetlist_def(query, confl->onConflictSet,
    6815             :                                             context, rte);
    6816             : 
    6817             :             /* Add a WHERE clause if given */
    6818          12 :             if (confl->onConflictWhere != NULL)
    6819             :             {
    6820          12 :                 appendContextKeyword(context, " WHERE ",
    6821             :                                      -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
    6822          12 :                 get_rule_expr(confl->onConflictWhere, context, false);
    6823             :             }
    6824             :         }
    6825             :     }
    6826             : 
    6827             :     /* Add RETURNING if present */
    6828         340 :     if (query->returningList)
    6829             :     {
    6830          78 :         appendContextKeyword(context, " RETURNING",
    6831             :                              -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
    6832          78 :         get_target_list(query->returningList, context);
    6833             :     }
    6834         340 : }
    6835             : 
    6836             : 
    6837             : /* ----------
    6838             :  * get_update_query_def         - Parse back an UPDATE parsetree
    6839             :  * ----------
    6840             :  */
    6841             : static void
    6842         130 : get_update_query_def(Query *query, deparse_context *context)
    6843             : {
    6844         130 :     StringInfo  buf = context->buf;
    6845             :     RangeTblEntry *rte;
    6846             : 
    6847             :     /* Insert the WITH clause if given */
    6848         130 :     get_with_clause(query, context);
    6849             : 
    6850             :     /*
    6851             :      * Start the query with UPDATE relname SET
    6852             :      */
    6853         130 :     rte = rt_fetch(query->resultRelation, query->rtable);
    6854             :     Assert(rte->rtekind == RTE_RELATION);
    6855         130 :     if (PRETTY_INDENT(context))
    6856             :     {
    6857         130 :         appendStringInfoChar(buf, ' ');
    6858         130 :         context->indentLevel += PRETTYINDENT_STD;
    6859             :     }
    6860         260 :     appendStringInfo(buf, "UPDATE %s%s",
    6861         130 :                      only_marker(rte),
    6862             :                      generate_relation_name(rte->relid, NIL));
    6863             : 
    6864             :     /* Print the relation alias, if needed */
    6865         130 :     get_rte_alias(rte, query->resultRelation, false, context);
    6866             : 
    6867         130 :     appendStringInfoString(buf, " SET ");
    6868             : 
    6869             :     /* Deparse targetlist */
    6870         130 :     get_update_query_targetlist_def(query, query->targetList, context, rte);
    6871             : 
    6872             :     /* Add the FROM clause if needed */
    6873         130 :     get_from_clause(query, " FROM ", context);
    6874             : 
    6875             :     /* Add a WHERE clause if given */
    6876         130 :     if (query->jointree->quals != NULL)
    6877             :     {
    6878         114 :         appendContextKeyword(context, " WHERE ",
    6879             :                              -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
    6880         114 :         get_rule_expr(query->jointree->quals, context, false);
    6881             :     }
    6882             : 
    6883             :     /* Add RETURNING if present */
    6884         130 :     if (query->returningList)
    6885             :     {
    6886          22 :         appendContextKeyword(context, " RETURNING",
    6887             :                              -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
    6888          22 :         get_target_list(query->returningList, context);
    6889             :     }
    6890         130 : }
    6891             : 
    6892             : 
    6893             : /* ----------
    6894             :  * get_update_query_targetlist_def          - Parse back an UPDATE targetlist
    6895             :  * ----------
    6896             :  */
    6897             : static void
    6898         166 : get_update_query_targetlist_def(Query *query, List *targetList,
    6899             :                                 deparse_context *context, RangeTblEntry *rte)
    6900             : {
    6901         166 :     StringInfo  buf = context->buf;
    6902             :     ListCell   *l;
    6903             :     ListCell   *next_ma_cell;
    6904             :     int         remaining_ma_columns;
    6905             :     const char *sep;
    6906             :     SubLink    *cur_ma_sublink;
    6907             :     List       *ma_sublinks;
    6908             : 
    6909             :     /*
    6910             :      * Prepare to deal with MULTIEXPR assignments: collect the source SubLinks
    6911             :      * into a list.  We expect them to appear, in ID order, in resjunk tlist
    6912             :      * entries.
    6913             :      */
    6914         166 :     ma_sublinks = NIL;
    6915         166 :     if (query->hasSubLinks)      /* else there can't be any */
    6916             :     {
    6917          30 :         foreach(l, targetList)
    6918             :         {
    6919          24 :             TargetEntry *tle = (TargetEntry *) lfirst(l);
    6920             : 
    6921          24 :             if (tle->resjunk && IsA(tle->expr, SubLink))
    6922             :             {
    6923           6 :                 SubLink    *sl = (SubLink *) tle->expr;
    6924             : 
    6925           6 :                 if (sl->subLinkType == MULTIEXPR_SUBLINK)
    6926             :                 {
    6927           6 :                     ma_sublinks = lappend(ma_sublinks, sl);
    6928             :                     Assert(sl->subLinkId == list_length(ma_sublinks));
    6929             :                 }
    6930             :             }
    6931             :         }
    6932             :     }
    6933         166 :     next_ma_cell = list_head(ma_sublinks);
    6934         166 :     cur_ma_sublink = NULL;
    6935         166 :     remaining_ma_columns = 0;
    6936             : 
    6937             :     /* Add the comma separated list of 'attname = value' */
    6938         166 :     sep = "";
    6939         440 :     foreach(l, targetList)
    6940             :     {
    6941         274 :         TargetEntry *tle = (TargetEntry *) lfirst(l);
    6942             :         Node       *expr;
    6943             : 
    6944         274 :         if (tle->resjunk)
    6945           6 :             continue;           /* ignore junk entries */
    6946             : 
    6947             :         /* Emit separator (OK whether we're in multiassignment or not) */
    6948         268 :         appendStringInfoString(buf, sep);
    6949         268 :         sep = ", ";
    6950             : 
    6951             :         /*
    6952             :          * Check to see if we're starting a multiassignment group: if so,
    6953             :          * output a left paren.
    6954             :          */
    6955         268 :         if (next_ma_cell != NULL && cur_ma_sublink == NULL)
    6956             :         {
    6957             :             /*
    6958             :              * We must dig down into the expr to see if it's a PARAM_MULTIEXPR
    6959             :              * Param.  That could be buried under FieldStores and
    6960             :              * SubscriptingRefs and CoerceToDomains (cf processIndirection()),
    6961             :              * and underneath those there could be an implicit type coercion.
    6962             :              * Because we would ignore implicit type coercions anyway, we
    6963             :              * don't need to be as careful as processIndirection() is about
    6964             :              * descending past implicit CoerceToDomains.
    6965             :              */
    6966           6 :             expr = (Node *) tle->expr;
    6967          12 :             while (expr)
    6968             :             {
    6969          12 :                 if (IsA(expr, FieldStore))
    6970             :                 {
    6971           0 :                     FieldStore *fstore = (FieldStore *) expr;
    6972             : 
    6973           0 :                     expr = (Node *) linitial(fstore->newvals);
    6974             :                 }
    6975          12 :                 else if (IsA(expr, SubscriptingRef))
    6976             :                 {
    6977           6 :                     SubscriptingRef *sbsref = (SubscriptingRef *) expr;
    6978             : 
    6979           6 :                     if (sbsref->refassgnexpr == NULL)
    6980           0 :                         break;
    6981             : 
    6982           6 :                     expr = (Node *) sbsref->refassgnexpr;
    6983             :                 }
    6984           6 :                 else if (IsA(expr, CoerceToDomain))
    6985             :                 {
    6986           0 :                     CoerceToDomain *cdomain = (CoerceToDomain *) expr;
    6987             : 
    6988           0 :                     if (cdomain->coercionformat != COERCE_IMPLICIT_CAST)
    6989           0 :                         break;
    6990           0 :                     expr = (Node *) cdomain->arg;
    6991             :                 }
    6992             :                 else
    6993           6 :                     break;
    6994             :             }
    6995           6 :             expr = strip_implicit_coercions(expr);
    6996             : 
    6997           6 :             if (expr && IsA(expr, Param) &&
    6998           6 :                 ((Param *) expr)->paramkind == PARAM_MULTIEXPR)
    6999             :             {
    7000           6 :                 cur_ma_sublink = (SubLink *) lfirst(next_ma_cell);
    7001           6 :                 next_ma_cell = lnext(ma_sublinks, next_ma_cell);
    7002           6 :                 remaining_ma_columns = count_nonjunk_tlist_entries(((Query *) cur_ma_sublink->subselect)->targetList);
    7003             :                 Assert(((Param *) expr)->paramid ==
    7004             :                        ((cur_ma_sublink->subLinkId << 16) | 1));
    7005           6 :                 appendStringInfoChar(buf, '(');
    7006             :             }
    7007             :         }
    7008             : 
    7009             :         /*
    7010             :          * Put out name of target column; look in the catalogs, not at
    7011             :          * tle->resname, since resname will fail to track RENAME.
    7012             :          */
    7013         268 :         appendStringInfoString(buf,
    7014         268 :                                quote_identifier(get_attname(rte->relid,
    7015         268 :                                                             tle->resno,
    7016             :                                                             false)));
    7017             : 
    7018             :         /*
    7019             :          * Print any indirection needed (subfields or subscripts), and strip
    7020             :          * off the top-level nodes representing the indirection assignments.
    7021             :          */
    7022         268 :         expr = processIndirection((Node *) tle->expr, context);
    7023             : 
    7024             :         /*
    7025             :          * If we're in a multiassignment, skip printing anything more, unless
    7026             :          * this is the last column; in which case, what we print should be the
    7027             :          * sublink, not the Param.
    7028             :          */
    7029         268 :         if (cur_ma_sublink != NULL)
    7030             :         {
    7031          18 :             if (--remaining_ma_columns > 0)
    7032          12 :                 continue;       /* not the last column of multiassignment */
    7033           6 :             appendStringInfoChar(buf, ')');
    7034           6 :             expr = (Node *) cur_ma_sublink;
    7035           6 :             cur_ma_sublink = NULL;
    7036             :         }
    7037             : 
    7038         256 :         appendStringInfoString(buf, " = ");
    7039             : 
    7040         256 :         get_rule_expr(expr, context, false);
    7041             :     }
    7042         166 : }
    7043             : 
    7044             : 
    7045             : /* ----------
    7046             :  * get_delete_query_def         - Parse back a DELETE parsetree
    7047             :  * ----------
    7048             :  */
    7049             : static void
    7050          76 : get_delete_query_def(Query *query, deparse_context *context)
    7051             : {
    7052          76 :     StringInfo  buf = context->buf;
    7053             :     RangeTblEntry *rte;
    7054             : 
    7055             :     /* Insert the WITH clause if given */
    7056          76 :     get_with_clause(query, context);
    7057             : 
    7058             :     /*
    7059             :      * Start the query with DELETE FROM relname
    7060             :      */
    7061          76 :     rte = rt_fetch(query->resultRelation, query->rtable);
    7062             :     Assert(rte->rtekind == RTE_RELATION);
    7063          76 :     if (PRETTY_INDENT(context))
    7064             :     {
    7065          76 :         appendStringInfoChar(buf, ' ');
    7066          76 :         context->indentLevel += PRETTYINDENT_STD;
    7067             :     }
    7068         152 :     appendStringInfo(buf, "DELETE FROM %s%s",
    7069          76 :                      only_marker(rte),
    7070             :                      generate_relation_name(rte->relid, NIL));
    7071             : 
    7072             :     /* Print the relation alias, if needed */
    7073          76 :     get_rte_alias(rte, query->resultRelation, false, context);
    7074             : 
    7075             :     /* Add the USING clause if given */
    7076          76 :     get_from_clause(query, " USING ", context);
    7077             : 
    7078             :     /* Add a WHERE clause if given */
    7079          76 :     if (query->jointree->quals != NULL)
    7080             :     {
    7081          76 :         appendContextKeyword(context, " WHERE ",
    7082             :                              -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
    7083          76 :         get_rule_expr(query->jointree->quals, context, false);
    7084             :     }
    7085             : 
    7086             :     /* Add RETURNING if present */
    7087          76 :     if (query->returningList)
    7088             :     {
    7089          16 :         appendContextKeyword(context, " RETURNING",
    7090             :                              -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
    7091          16 :         get_target_list(query->returningList, context);
    7092             :     }
    7093          76 : }
    7094             : 
    7095             : 
    7096             : /* ----------
    7097             :  * get_merge_query_def              - Parse back a MERGE parsetree
    7098             :  * ----------
    7099             :  */
    7100             : static void
    7101          12 : get_merge_query_def(Query *query, deparse_context *context)
    7102             : {
    7103          12 :     StringInfo  buf = context->buf;
    7104             :     RangeTblEntry *rte;
    7105             :     ListCell   *lc;
    7106             :     bool        haveNotMatchedBySource;
    7107             : 
    7108             :     /* Insert the WITH clause if given */
    7109          12 :     get_with_clause(query, context);
    7110             : 
    7111             :     /*
    7112             :      * Start the query with MERGE INTO relname
    7113             :      */
    7114          12 :     rte = rt_fetch(query->resultRelation, query->rtable);
    7115             :     Assert(rte->rtekind == RTE_RELATION);
    7116          12 :     if (PRETTY_INDENT(context))
    7117             :     {
    7118          12 :         appendStringInfoChar(buf, ' ');
    7119          12 :         context->indentLevel += PRETTYINDENT_STD;
    7120             :     }
    7121          24 :     appendStringInfo(buf, "MERGE INTO %s%s",
    7122          12 :                      only_marker(rte),
    7123             :                      generate_relation_name(rte->relid, NIL));
    7124             : 
    7125             :     /* Print the relation alias, if needed */
    7126          12 :     get_rte_alias(rte, query->resultRelation, false, context);
    7127             : 
    7128             :     /* Print the source relation and join clause */
    7129          12 :     get_from_clause(query, " USING ", context);
    7130          12 :     appendContextKeyword(context, " ON ",
    7131             :                          -PRETTYINDENT_STD, PRETTYINDENT_STD, 2);
    7132          12 :     get_rule_expr(query->mergeJoinCondition, context, false);
    7133             : 
    7134             :     /*
    7135             :      * Test for any NOT MATCHED BY SOURCE actions.  If there are none, then
    7136             :      * any NOT MATCHED BY TARGET actions are output as "WHEN NOT MATCHED", per
    7137             :      * SQL standard.  Otherwise, we have a non-SQL-standard query, so output
    7138             :      * "BY SOURCE" / "BY TARGET" qualifiers for all NOT MATCHED actions, to be
    7139             :      * more explicit.
    7140             :      */
    7141          12 :     haveNotMatchedBySource = false;
    7142          84 :     foreach(lc, query->mergeActionList)
    7143             :     {
    7144          78 :         MergeAction *action = lfirst_node(MergeAction, lc);
    7145             : 
    7146          78 :         if (action->matchKind == MERGE_WHEN_NOT_MATCHED_BY_SOURCE)
    7147             :         {
    7148           6 :             haveNotMatchedBySource = true;
    7149           6 :             break;
    7150             :         }
    7151             :     }
    7152             : 
    7153             :     /* Print each merge action */
    7154          90 :     foreach(lc, query->mergeActionList)
    7155             :     {
    7156          78 :         MergeAction *action = lfirst_node(MergeAction, lc);
    7157             : 
    7158          78 :         appendContextKeyword(context, " WHEN ",
    7159             :                              -PRETTYINDENT_STD, PRETTYINDENT_STD, 2);
    7160          78 :         switch (action->matchKind)
    7161             :         {
    7162          36 :             case MERGE_WHEN_MATCHED:
    7163          36 :                 appendStringInfoString(buf, "MATCHED");
    7164          36 :                 break;
    7165           6 :             case MERGE_WHEN_NOT_MATCHED_BY_SOURCE:
    7166           6 :                 appendStringInfoString(buf, "NOT MATCHED BY SOURCE");
    7167           6 :                 break;
    7168          36 :             case MERGE_WHEN_NOT_MATCHED_BY_TARGET:
    7169          36 :                 if (haveNotMatchedBySource)
    7170           6 :                     appendStringInfoString(buf, "NOT MATCHED BY TARGET");
    7171             :                 else
    7172          30 :                     appendStringInfoString(buf, "NOT MATCHED");
    7173          36 :                 break;
    7174           0 :             default:
    7175           0 :                 elog(ERROR, "unrecognized matchKind: %d",
    7176             :                      (int) action->matchKind);
    7177             :         }
    7178             : 
    7179          78 :         if (action->qual)
    7180             :         {
    7181          48 :             appendContextKeyword(context, " AND ",
    7182             :                                  -PRETTYINDENT_STD, PRETTYINDENT_STD, 3);
    7183          48 :             get_rule_expr(action->qual, context, false);
    7184             :         }
    7185          78 :         appendContextKeyword(context, " THEN ",
    7186             :                              -PRETTYINDENT_STD, PRETTYINDENT_STD, 3);
    7187             : 
    7188          78 :         if (action->commandType == CMD_INSERT)
    7189             :         {
    7190             :             /* This generally matches get_insert_query_def() */
    7191          36 :             List       *strippedexprs = NIL;
    7192          36 :             const char *sep = "";
    7193             :             ListCell   *lc2;
    7194             : 
    7195          36 :             appendStringInfoString(buf, "INSERT");
    7196             : 
    7197          36 :             if (action->targetList)
    7198          30 :                 appendStringInfoString(buf, " (");
    7199         102 :             foreach(lc2, action->targetList)
    7200             :             {
    7201          66 :                 TargetEntry *tle = (TargetEntry *) lfirst(lc2);
    7202             : 
    7203             :                 Assert(!tle->resjunk);
    7204             : 
    7205          66 :                 appendStringInfoString(buf, sep);
    7206          66 :                 sep = ", ";
    7207             : 
    7208          66 :                 appendStringInfoString(buf,
    7209          66 :                                        quote_identifier(get_attname(rte->relid,
    7210          66 :                                                                     tle->resno,
    7211             :                                                                     false)));
    7212          66 :                 strippedexprs = lappend(strippedexprs,
    7213          66 :                                         processIndirection((Node *) tle->expr,
    7214             :                                                            context));
    7215             :             }
    7216          36 :             if (action->targetList)
    7217          30 :                 appendStringInfoChar(buf, ')');
    7218             : 
    7219          36 :             if (action->override)
    7220             :             {
    7221           6 :                 if (action->override == OVERRIDING_SYSTEM_VALUE)
    7222           0 :                     appendStringInfoString(buf, " OVERRIDING SYSTEM VALUE");
    7223           6 :                 else if (action->override == OVERRIDING_USER_VALUE)
    7224           6 :                     appendStringInfoString(buf, " OVERRIDING USER VALUE");
    7225             :             }
    7226             : 
    7227          36 :             if (strippedexprs)
    7228             :             {
    7229          30 :                 appendContextKeyword(context, " VALUES (",
    7230             :                                      -PRETTYINDENT_STD, PRETTYINDENT_STD, 4);
    7231          30 :                 get_rule_list_toplevel(strippedexprs, context, false);
    7232          30 :                 appendStringInfoChar(buf, ')');
    7233             :             }
    7234             :             else
    7235           6 :                 appendStringInfoString(buf, " DEFAULT VALUES");
    7236             :         }
    7237          42 :         else if (action->commandType == CMD_UPDATE)
    7238             :         {
    7239          24 :             appendStringInfoString(buf, "UPDATE SET ");
    7240          24 :             get_update_query_targetlist_def(query, action->targetList,
    7241             :                                             context, rte);
    7242             :         }
    7243          18 :         else if (action->commandType == CMD_DELETE)
    7244          12 :             appendStringInfoString(buf, "DELETE");
    7245           6 :         else if (action->commandType == CMD_NOTHING)
    7246           6 :             appendStringInfoString(buf, "DO NOTHING");
    7247             :     }
    7248             : 
    7249             :     /* Add RETURNING if present */
    7250          12 :     if (query->returningList)
    7251             :     {
    7252           6 :         appendContextKeyword(context, " RETURNING",
    7253             :                              -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
    7254           6 :         get_target_list(query->returningList, context);
    7255             :     }
    7256          12 : }
    7257             : 
    7258             : 
    7259             : /* ----------
    7260             :  * get_utility_query_def            - Parse back a UTILITY parsetree
    7261             :  * ----------
    7262             :  */
    7263             : static void
    7264          16 : get_utility_query_def(Query *query, deparse_context *context)
    7265             : {
    7266          16 :     StringInfo  buf = context->buf;
    7267             : 
    7268          16 :     if (query->utilityStmt && IsA(query->utilityStmt, NotifyStmt))
    7269          16 :     {
    7270          16 :         NotifyStmt *stmt = (NotifyStmt *) query->utilityStmt;
    7271             : 
    7272          16 :         appendContextKeyword(context, "",
    7273             :                              0, PRETTYINDENT_STD, 1);
    7274          16 :         appendStringInfo(buf, "NOTIFY %s",
    7275          16 :                          quote_identifier(stmt->conditionname));
    7276          16 :         if (stmt->payload)
    7277             :         {
    7278           0 :             appendStringInfoString(buf, ", ");
    7279           0 :             simple_quote_literal(buf, stmt->payload);
    7280             :         }
    7281             :     }
    7282             :     else
    7283             :     {
    7284             :         /* Currently only NOTIFY utility commands can appear in rules */
    7285           0 :         elog(ERROR, "unexpected utility statement type");
    7286             :     }
    7287          16 : }
    7288             : 
    7289             : /*
    7290             :  * Display a Var appropriately.
    7291             :  *
    7292             :  * In some cases (currently only when recursing into an unnamed join)
    7293             :  * the Var's varlevelsup has to be interpreted with respect to a context
    7294             :  * above the current one; levelsup indicates the offset.
    7295             :  *
    7296             :  * If istoplevel is true, the Var is at the top level of a SELECT's
    7297             :  * targetlist, which means we need special treatment of whole-row Vars.
    7298             :  * Instead of the normal "tab.*", we'll print "tab.*::typename", which is a
    7299             :  * dirty hack to prevent "tab.*" from being expanded into multiple columns.
    7300             :  * (The parser will strip the useless coercion, so no inefficiency is added in
    7301             :  * dump and reload.)  We used to print just "tab" in such cases, but that is
    7302             :  * ambiguous and will yield the wrong result if "tab" is also a plain column
    7303             :  * name in the query.
    7304             :  *
    7305             :  * Returns the attname of the Var, or NULL if the Var has no attname (because
    7306             :  * it is a whole-row Var or a subplan output reference).
    7307             :  */
    7308             : static char *
    7309      151180 : get_variable(Var *var, int levelsup, bool istoplevel, deparse_context *context)
    7310             : {
    7311      151180 :     StringInfo  buf = context->buf;
    7312             :     RangeTblEntry *rte;
    7313             :     AttrNumber  attnum;
    7314             :     int         netlevelsup;
    7315             :     deparse_namespace *dpns;
    7316             :     int         varno;
    7317             :     AttrNumber  varattno;
    7318             :     deparse_columns *colinfo;
    7319             :     char       *refname;
    7320             :     char       *attname;
    7321             :     bool        need_prefix;
    7322             : 
    7323             :     /* Find appropriate nesting depth */
    7324      151180 :     netlevelsup = var->varlevelsup + levelsup;
    7325      151180 :     if (netlevelsup >= list_length(context->namespaces))
    7326           0 :         elog(ERROR, "bogus varlevelsup: %d offset %d",
    7327             :              var->varlevelsup, levelsup);
    7328      151180 :     dpns = (deparse_namespace *) list_nth(context->namespaces,
    7329             :                                           netlevelsup);
    7330             : 
    7331             :     /*
    7332             :      * If we have a syntactic referent for the Var, and we're working from a
    7333             :      * parse tree, prefer to use the syntactic referent.  Otherwise, fall back
    7334             :      * on the semantic referent.  (Forcing use of the semantic referent when
    7335             :      * printing plan trees is a design choice that's perhaps more motivated by
    7336             :      * backwards compatibility than anything else.  But it does have the
    7337             :      * advantage of making plans more explicit.)
    7338             :      */
    7339      151180 :     if (var->varnosyn > 0 && dpns->plan == NULL)
    7340             :     {
    7341       35210 :         varno = var->varnosyn;
    7342       35210 :         varattno = var->varattnosyn;
    7343             :     }
    7344             :     else
    7345             :     {
    7346      115970 :         varno = var->varno;
    7347      115970 :         varattno = var->varattno;
    7348             :     }
    7349             : 
    7350             :     /*
    7351             :      * Try to find the relevant RTE in this rtable.  In a plan tree, it's
    7352             :      * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
    7353             :      * down into the subplans, or INDEX_VAR, which is resolved similarly. Also
    7354             :      * find the aliases previously assigned for this RTE.
    7355             :      */
    7356      151180 :     if (varno >= 1 && varno <= list_length(dpns->rtable))
    7357             :     {
    7358             :         /*
    7359             :          * We might have been asked to map child Vars to some parent relation.
    7360             :          */
    7361      114502 :         if (context->appendparents && dpns->appendrels)
    7362             :         {
    7363        3524 :             int         pvarno = varno;
    7364        3524 :             AttrNumber  pvarattno = varattno;
    7365        3524 :             AppendRelInfo *appinfo = dpns->appendrels[pvarno];
    7366        3524 :             bool        found = false;
    7367             : 
    7368             :             /* Only map up to inheritance parents, not UNION ALL appendrels */
    7369        7182 :             while (appinfo &&
    7370        3936 :                    rt_fetch(appinfo->parent_relid,
    7371        3936 :                             dpns->rtable)->rtekind == RTE_RELATION)
    7372             :             {
    7373        3658 :                 found = false;
    7374        3658 :                 if (pvarattno > 0)   /* system columns stay as-is */
    7375             :                 {
    7376        3384 :                     if (pvarattno > appinfo->num_child_cols)
    7377           0 :                         break;  /* safety check */
    7378        3384 :                     pvarattno = appinfo->parent_colnos[pvarattno - 1];
    7379        3384 :                     if (pvarattno == 0)
    7380           0 :                         break;  /* Var is local to child */
    7381             :                 }
    7382             : 
    7383        3658 :                 pvarno = appinfo->parent_relid;
    7384        3658 :                 found = true;
    7385             : 
    7386             :                 /* If the parent is itself a child, continue up. */
    7387             :                 Assert(pvarno > 0 && pvarno <= list_length(dpns->rtable));
    7388        3658 :                 appinfo = dpns->appendrels[pvarno];
    7389             :             }
    7390             : 
    7391             :             /*
    7392             :              * If we found an ancestral rel, and that rel is included in
    7393             :              * appendparents, print that column not the original one.
    7394             :              */
    7395        3524 :             if (found && bms_is_member(pvarno, context->appendparents))
    7396             :             {
    7397        2892 :                 varno = pvarno;
    7398        2892 :                 varattno = pvarattno;
    7399             :             }
    7400             :         }
    7401             : 
    7402      114502 :         rte = rt_fetch(varno, dpns->rtable);
    7403      114502 :         refname = (char *) list_nth(dpns->rtable_names, varno - 1);
    7404      114502 :         colinfo = deparse_columns_fetch(varno, dpns);
    7405      114502 :         attnum = varattno;
    7406             :     }
    7407             :     else
    7408             :     {
    7409       36678 :         resolve_special_varno((Node *) var, context,
    7410             :                               get_special_variable, NULL);
    7411       36678 :         return NULL;
    7412             :     }
    7413             : 
    7414             :     /*
    7415             :      * The planner will sometimes emit Vars referencing resjunk elements of a
    7416             :      * subquery's target list (this is currently only possible if it chooses
    7417             :      * to generate a "physical tlist" for a SubqueryScan or CteScan node).
    7418             :      * Although we prefer to print subquery-referencing Vars using the
    7419             :      * subquery's alias, that's not possible for resjunk items since they have
    7420             :      * no alias.  So in that case, drill down to the subplan and print the
    7421             :      * contents of the referenced tlist item.  This works because in a plan
    7422             :      * tree, such Vars can only occur in a SubqueryScan or CteScan node, and
    7423             :      * we'll have set dpns->inner_plan to reference the child plan node.
    7424             :      */
    7425      118684 :     if ((rte->rtekind == RTE_SUBQUERY || rte->rtekind == RTE_CTE) &&
    7426        4182 :         attnum > list_length(rte->eref->colnames) &&
    7427           2 :         dpns->inner_plan)
    7428             :     {
    7429             :         TargetEntry *tle;
    7430             :         deparse_namespace save_dpns;
    7431             : 
    7432           2 :         tle = get_tle_by_resno(dpns->inner_tlist, attnum);
    7433           2 :         if (!tle)
    7434           0 :             elog(ERROR, "invalid attnum %d for relation \"%s\"",
    7435             :                  attnum, rte->eref->aliasname);
    7436             : 
    7437             :         Assert(netlevelsup == 0);
    7438           2 :         push_child_plan(dpns, dpns->inner_plan, &save_dpns);
    7439             : 
    7440             :         /*
    7441             :          * Force parentheses because our caller probably assumed a Var is a
    7442             :          * simple expression.
    7443             :          */
    7444           2 :         if (!IsA(tle->expr, Var))
    7445           0 :             appendStringInfoChar(buf, '(');
    7446           2 :         get_rule_expr((Node *) tle->expr, context, true);
    7447           2 :         if (!IsA(tle->expr, Var))
    7448           0 :             appendStringInfoChar(buf, ')');
    7449             : 
    7450           2 :         pop_child_plan(dpns, &save_dpns);
    7451           2 :         return NULL;
    7452             :     }
    7453             : 
    7454             :     /*
    7455             :      * If it's an unnamed join, look at the expansion of the alias variable.
    7456             :      * If it's a simple reference to one of the input vars, then recursively
    7457             :      * print the name of that var instead.  When it's not a simple reference,
    7458             :      * we have to just print the unqualified join column name.  (This can only
    7459             :      * happen with "dangerous" merged columns in a JOIN USING; we took pains
    7460             :      * previously to make the unqualified column name unique in such cases.)
    7461             :      *
    7462             :      * This wouldn't work in decompiling plan trees, because we don't store
    7463             :      * joinaliasvars lists after planning; but a plan tree should never
    7464             :      * contain a join alias variable.
    7465             :      */
    7466      114500 :     if (rte->rtekind == RTE_JOIN && rte->alias == NULL)
    7467             :     {
    7468          96 :         if (rte->joinaliasvars == NIL)
    7469           0 :             elog(ERROR, "cannot decompile join alias var in plan tree");
    7470          96 :         if (attnum > 0)
    7471             :         {
    7472             :             Var        *aliasvar;
    7473             : 
    7474          96 :             aliasvar = (Var *) list_nth(rte->joinaliasvars, attnum - 1);
    7475             :             /* we intentionally don't strip implicit coercions here */
    7476          96 :             if (aliasvar && IsA(aliasvar, Var))
    7477             :             {
    7478           0 :                 return get_variable(aliasvar, var->varlevelsup + levelsup,
    7479             :                                     istoplevel, context);
    7480             :             }
    7481             :         }
    7482             : 
    7483             :         /*
    7484             :          * Unnamed join has no refname.  (Note: since it's unnamed, there is
    7485             :          * no way the user could have referenced it to create a whole-row Var
    7486             :          * for it.  So we don't have to cover that case below.)
    7487             :          */
    7488             :         Assert(refname == NULL);
    7489             :     }
    7490             : 
    7491      114500 :     if (attnum == InvalidAttrNumber)
    7492         820 :         attname = NULL;
    7493      113680 :     else if (attnum > 0)
    7494             :     {
    7495             :         /* Get column name to use from the colinfo struct */
    7496      112312 :         if (attnum > colinfo->num_cols)
    7497           0 :             elog(ERROR, "invalid attnum %d for relation \"%s\"",
    7498             :                  attnum, rte->eref->aliasname);
    7499      112312 :         attname = colinfo->colnames[attnum - 1];
    7500             : 
    7501             :         /*
    7502             :          * If we find a Var referencing a dropped column, it seems better to
    7503             :          * print something (anything) than to fail.  In general this should
    7504             :          * not happen, but it used to be possible for some cases involving
    7505             :          * functions returning named composite types, and perhaps there are
    7506             :          * still bugs out there.
    7507             :          */
    7508      112312 :         if (attname == NULL)
    7509           6 :             attname = "?dropped?column?";
    7510             :     }
    7511             :     else
    7512             :     {
    7513             :         /* System column - name is fixed, get it from the catalog */
    7514        1368 :         attname = get_rte_attribute_name(rte, attnum);
    7515             :     }
    7516             : 
    7517      114500 :     need_prefix = (context->varprefix || attname == NULL);
    7518             : 
    7519             :     /*
    7520             :      * If we're considering a plain Var in an ORDER BY (but not GROUP BY)
    7521             :      * clause, we may need to add a table-name prefix to prevent
    7522             :      * findTargetlistEntrySQL92 from misinterpreting the name as an
    7523             :      * output-column name.  To avoid cluttering the output with unnecessary
    7524             :      * prefixes, do so only if there is a name match to a SELECT tlist item
    7525             :      * that is different from the Var.
    7526             :      */
    7527      114500 :     if (context->varInOrderBy && !context->inGroupBy && !need_prefix)
    7528             :     {
    7529         224 :         int         colno = 0;
    7530             : 
    7531         874 :         foreach_node(TargetEntry, tle, context->targetList)
    7532             :         {
    7533             :             char       *colname;
    7534             : 
    7535         438 :             if (tle->resjunk)
    7536           0 :                 continue;       /* ignore junk entries */
    7537         438 :             colno++;
    7538             : 
    7539             :             /* This must match colname-choosing logic in get_target_list() */
    7540         438 :             if (context->resultDesc && colno <= context->resultDesc->natts)
    7541         438 :                 colname = NameStr(TupleDescAttr(context->resultDesc,
    7542             :                                                 colno - 1)->attname);
    7543             :             else
    7544           0 :                 colname = tle->resname;
    7545             : 
    7546         438 :             if (colname && strcmp(colname, attname) == 0 &&
    7547         152 :                 !equal(var, tle->expr))
    7548             :             {
    7549          12 :                 need_prefix = true;
    7550          12 :                 break;
    7551             :             }
    7552             :         }
    7553             :     }
    7554             : 
    7555      114500 :     if (refname && need_prefix)
    7556             :     {
    7557       55626 :         appendStringInfoString(buf, quote_identifier(refname));
    7558       55626 :         appendStringInfoChar(buf, '.');
    7559             :     }
    7560      114500 :     if (attname)
    7561      113680 :         appendStringInfoString(buf, quote_identifier(attname));
    7562             :     else
    7563             :     {
    7564         820 :         appendStringInfoChar(buf, '*');
    7565         820 :         if (istoplevel)
    7566          72 :             appendStringInfo(buf, "::%s",
    7567             :                              format_type_with_typemod(var->vartype,
    7568             :                                                       var->vartypmod));
    7569             :     }
    7570             : 
    7571      114500 :     return attname;
    7572             : }
    7573             : 
    7574             : /*
    7575             :  * Deparse a Var which references OUTER_VAR, INNER_VAR, or INDEX_VAR.  This
    7576             :  * routine is actually a callback for resolve_special_varno, which handles
    7577             :  * finding the correct TargetEntry.  We get the expression contained in that
    7578             :  * TargetEntry and just need to deparse it, a job we can throw back on
    7579             :  * get_rule_expr.
    7580             :  */
    7581             : static void
    7582       36678 : get_special_variable(Node *node, deparse_context *context, void *callback_arg)
    7583             : {
    7584       36678 :     StringInfo  buf = context->buf;
    7585             : 
    7586             :     /*
    7587             :      * For a non-Var referent, force parentheses because our caller probably
    7588             :      * assumed a Var is a simple expression.
    7589             :      */
    7590       36678 :     if (!IsA(node, Var))
    7591        3034 :         appendStringInfoChar(buf, '(');
    7592       36678 :     get_rule_expr(node, context, true);
    7593       36678 :     if (!IsA(node, Var))
    7594        3034 :         appendStringInfoChar(buf, ')');
    7595       36678 : }
    7596             : 
    7597             : /*
    7598             :  * Chase through plan references to special varnos (OUTER_VAR, INNER_VAR,
    7599             :  * INDEX_VAR) until we find a real Var or some kind of non-Var node; then,
    7600             :  * invoke the callback provided.
    7601             :  */
    7602             : static void
    7603      100932 : resolve_special_varno(Node *node, deparse_context *context,
    7604             :                       rsv_callback callback, void *callback_arg)
    7605             : {
    7606             :     Var        *var;
    7607             :     deparse_namespace *dpns;
    7608             : 
    7609             :     /* This function is recursive, so let's be paranoid. */
    7610      100932 :     check_stack_depth();
    7611             : 
    7612             :     /* If it's not a Var, invoke the callback. */
    7613      100932 :     if (!IsA(node, Var))
    7614             :     {
    7615        3294 :         (*callback) (node, context, callback_arg);
    7616        3294 :         return;
    7617             :     }
    7618             : 
    7619             :     /* Find appropriate nesting depth */
    7620       97638 :     var = (Var *) node;
    7621       97638 :     dpns = (deparse_namespace *) list_nth(context->namespaces,
    7622       97638 :                                           var->varlevelsup);
    7623             : 
    7624             :     /*
    7625             :      * If varno is special, recurse.  (Don't worry about varnosyn; if we're
    7626             :      * here, we already decided not to use that.)
    7627             :      */
    7628       97638 :     if (var->varno == OUTER_VAR && dpns->outer_tlist)
    7629             :     {
    7630             :         TargetEntry *tle;
    7631             :         deparse_namespace save_dpns;
    7632             :         Bitmapset  *save_appendparents;
    7633             : 
    7634       47664 :         tle = get_tle_by_resno(dpns->outer_tlist, var->varattno);
    7635       47664 :         if (!tle)
    7636           0 :             elog(ERROR, "bogus varattno for OUTER_VAR var: %d", var->varattno);
    7637             : 
    7638             :         /*
    7639             :          * If we're descending to the first child of an Append or MergeAppend,
    7640             :          * update appendparents.  This will affect deparsing of all Vars
    7641             :          * appearing within the eventually-resolved subexpression.
    7642             :          */
    7643       47664 :         save_appendparents = context->appendparents;
    7644             : 
    7645       47664 :         if (IsA(dpns->plan, Append))
    7646        3888 :             context->appendparents = bms_union(context->appendparents,
    7647        3888 :                                                ((Append *) dpns->plan)->apprelids);
    7648       43776 :         else if (IsA(dpns->plan, MergeAppend))
    7649         542 :             context->appendparents = bms_union(context->appendparents,
    7650         542 :                                                ((MergeAppend *) dpns->plan)->apprelids);
    7651             : 
    7652       47664 :         push_child_plan(dpns, dpns->outer_plan, &save_dpns);
    7653       47664 :         resolve_special_varno((Node *) tle->expr, context,
    7654             :                               callback, callback_arg);
    7655       47664 :         pop_child_plan(dpns, &save_dpns);
    7656       47664 :         context->appendparents = save_appendparents;
    7657       47664 :         return;
    7658             :     }
    7659       49974 :     else if (var->varno == INNER_VAR && dpns->inner_tlist)
    7660             :     {
    7661             :         TargetEntry *tle;
    7662             :         deparse_namespace save_dpns;
    7663             : 
    7664       11768 :         tle = get_tle_by_resno(dpns->inner_tlist, var->varattno);
    7665       11768 :         if (!tle)
    7666           0 :             elog(ERROR, "bogus varattno for INNER_VAR var: %d", var->varattno);
    7667             : 
    7668       11768 :         push_child_plan(dpns, dpns->inner_plan, &save_dpns);
    7669       11768 :         resolve_special_varno((Node *) tle->expr, context,
    7670             :                               callback, callback_arg);
    7671       11768 :         pop_child_plan(dpns, &save_dpns);
    7672       11768 :         return;
    7673             :     }
    7674       38206 :     else if (var->varno == INDEX_VAR && dpns->index_tlist)
    7675             :     {
    7676             :         TargetEntry *tle;
    7677             : 
    7678        4562 :         tle = get_tle_by_resno(dpns->index_tlist, var->varattno);
    7679        4562 :         if (!tle)
    7680           0 :             elog(ERROR, "bogus varattno for INDEX_VAR var: %d", var->varattno);
    7681             : 
    7682        4562 :         resolve_special_varno((Node *) tle->expr, context,
    7683             :                               callback, callback_arg);
    7684        4562 :         return;
    7685             :     }
    7686       33644 :     else if (var->varno < 1 || var->varno > list_length(dpns->rtable))
    7687           0 :         elog(ERROR, "bogus varno: %d", var->varno);
    7688             : 
    7689             :     /* Not special.  Just invoke the callback. */
    7690       33644 :     (*callback) (node, context, callback_arg);
    7691             : }
    7692             : 
    7693             : /*
    7694             :  * Get the name of a field of an expression of composite type.  The
    7695             :  * expression is usually a Var, but we handle other cases too.
    7696             :  *
    7697             :  * levelsup is an extra offset to interpret the Var's varlevelsup correctly.
    7698             :  *
    7699             :  * This is fairly straightforward when the expression has a named composite
    7700             :  * type; we need only look up the type in the catalogs.  However, the type
    7701             :  * could also be RECORD.  Since no actual table or view column is allowed to
    7702             :  * have type RECORD, a Var of type RECORD must refer to a JOIN or FUNCTION RTE
    7703             :  * or to a subquery output.  We drill down to find the ultimate defining
    7704             :  * expression and attempt to infer the field name from it.  We ereport if we
    7705             :  * can't determine the name.
    7706             :  *
    7707             :  * Similarly, a PARAM of type RECORD has to refer to some expression of
    7708             :  * a determinable composite type.
    7709             :  */
    7710             : static const char *
    7711        1304 : get_name_for_var_field(Var *var, int fieldno,
    7712             :                        int levelsup, deparse_context *context)
    7713             : {
    7714             :     RangeTblEntry *rte;
    7715             :     AttrNumber  attnum;
    7716             :     int         netlevelsup;
    7717             :     deparse_namespace *dpns;
    7718             :     int         varno;
    7719             :     AttrNumber  varattno;
    7720             :     TupleDesc   tupleDesc;
    7721             :     Node       *expr;
    7722             : 
    7723             :     /*
    7724             :      * If it's a RowExpr that was expanded from a whole-row Var, use the
    7725             :      * column names attached to it.  (We could let get_expr_result_tupdesc()
    7726             :      * handle this, but it's much cheaper to just pull out the name we need.)
    7727             :      */
    7728        1304 :     if (IsA(var, RowExpr))
    7729             :     {
    7730          36 :         RowExpr    *r = (RowExpr *) var;
    7731             : 
    7732          36 :         if (fieldno > 0 && fieldno <= list_length(r->colnames))
    7733          36 :             return strVal(list_nth(r->colnames, fieldno - 1));
    7734             :     }
    7735             : 
    7736             :     /*
    7737             :      * If it's a Param of type RECORD, try to find what the Param refers to.
    7738             :      */
    7739        1268 :     if (IsA(var, Param))
    7740             :     {
    7741          18 :         Param      *param = (Param *) var;
    7742             :         ListCell   *ancestor_cell;
    7743             : 
    7744          18 :         expr = find_param_referent(param, context, &dpns, &ancestor_cell);
    7745          18 :         if (expr)
    7746             :         {
    7747             :             /* Found a match, so recurse to decipher the field name */
    7748             :             deparse_namespace save_dpns;
    7749             :             const char *result;
    7750             : 
    7751          18 :             push_ancestor_plan(dpns, ancestor_cell, &save_dpns);
    7752          18 :             result = get_name_for_var_field((Var *) expr, fieldno,
    7753             :                                             0, context);
    7754          18 :             pop_ancestor_plan(dpns, &save_dpns);
    7755          18 :             return result;
    7756             :         }
    7757             :     }
    7758             : 
    7759             :     /*
    7760             :      * If it's a Var of type RECORD, we have to find what the Var refers to;
    7761             :      * if not, we can use get_expr_result_tupdesc().
    7762             :      */
    7763        1250 :     if (!IsA(var, Var) ||
    7764        1170 :         var->vartype != RECORDOID)
    7765             :     {
    7766        1004 :         tupleDesc = get_expr_result_tupdesc((Node *) var, false);
    7767             :         /* Got the tupdesc, so we can extract the field name */
    7768             :         Assert(fieldno >= 1 && fieldno <= tupleDesc->natts);
    7769        1004 :         return NameStr(TupleDescAttr(tupleDesc, fieldno - 1)->attname);
    7770             :     }
    7771             : 
    7772             :     /* Find appropriate nesting depth */
    7773         246 :     netlevelsup = var->varlevelsup + levelsup;
    7774         246 :     if (netlevelsup >= list_length(context->namespaces))
    7775           0 :         elog(ERROR, "bogus varlevelsup: %d offset %d",
    7776             :              var->varlevelsup, levelsup);
    7777         246 :     dpns = (deparse_namespace *) list_nth(context->namespaces,
    7778             :                                           netlevelsup);
    7779             : 
    7780             :     /*
    7781             :      * If we have a syntactic referent for the Var, and we're working from a
    7782             :      * parse tree, prefer to use the syntactic referent.  Otherwise, fall back
    7783             :      * on the semantic referent.  (See comments in get_variable().)
    7784             :      */
    7785         246 :     if (var->varnosyn > 0 && dpns->plan == NULL)
    7786             :     {
    7787          96 :         varno = var->varnosyn;
    7788          96 :         varattno = var->varattnosyn;
    7789             :     }
    7790             :     else
    7791             :     {
    7792         150 :         varno = var->varno;
    7793         150 :         varattno = var->varattno;
    7794             :     }
    7795             : 
    7796             :     /*
    7797             :      * Try to find the relevant RTE in this rtable.  In a plan tree, it's
    7798             :      * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
    7799             :      * down into the subplans, or INDEX_VAR, which is resolved similarly.
    7800             :      *
    7801             :      * Note: unlike get_variable and resolve_special_varno, we need not worry
    7802             :      * about inheritance mapping: a child Var should have the same datatype as
    7803             :      * its parent, and here we're really only interested in the Var's type.
    7804             :      */
    7805         246 :     if (varno >= 1 && varno <= list_length(dpns->rtable))
    7806             :     {
    7807         168 :         rte = rt_fetch(varno, dpns->rtable);
    7808         168 :         attnum = varattno;
    7809             :     }
    7810          78 :     else if (varno == OUTER_VAR && dpns->outer_tlist)
    7811             :     {
    7812             :         TargetEntry *tle;
    7813             :         deparse_namespace save_dpns;
    7814             :         const char *result;
    7815             : 
    7816          60 :         tle = get_tle_by_resno(dpns->outer_tlist, varattno);
    7817          60 :         if (!tle)
    7818           0 :             elog(ERROR, "bogus varattno for OUTER_VAR var: %d", varattno);
    7819             : 
    7820             :         Assert(netlevelsup == 0);
    7821          60 :         push_child_plan(dpns, dpns->outer_plan, &save_dpns);
    7822             : 
    7823          60 :         result = get_name_for_var_field((Var *) tle->expr, fieldno,
    7824             :                                         levelsup, context);
    7825             : 
    7826          60 :         pop_child_plan(dpns, &save_dpns);
    7827          60 :         return result;
    7828             :     }
    7829          18 :     else if (varno == INNER_VAR && dpns->inner_tlist)
    7830             :     {
    7831             :         TargetEntry *tle;
    7832             :         deparse_namespace save_dpns;
    7833             :         const char *result;
    7834             : 
    7835          18 :         tle = get_tle_by_resno(dpns->inner_tlist, varattno);
    7836          18 :         if (!tle)
    7837           0 :             elog(ERROR, "bogus varattno for INNER_VAR var: %d", varattno);
    7838             : 
    7839             :         Assert(netlevelsup == 0);
    7840          18 :         push_child_plan(dpns, dpns->inner_plan, &save_dpns);
    7841             : 
    7842          18 :         result = get_name_for_var_field((Var *) tle->expr, fieldno,
    7843             :                                         levelsup, context);
    7844             : 
    7845          18 :         pop_child_plan(dpns, &save_dpns);
    7846          18 :         return result;
    7847             :     }
    7848           0 :     else if (varno == INDEX_VAR && dpns->index_tlist)
    7849             :     {
    7850             :         TargetEntry *tle;
    7851             :         const char *result;
    7852             : 
    7853           0 :         tle = get_tle_by_resno(dpns->index_tlist, varattno);
    7854           0 :         if (!tle)
    7855           0 :             elog(ERROR, "bogus varattno for INDEX_VAR var: %d", varattno);
    7856             : 
    7857             :         Assert(netlevelsup == 0);
    7858             : 
    7859           0 :         result = get_name_for_var_field((Var *) tle->expr, fieldno,
    7860             :                                         levelsup, context);
    7861             : 
    7862           0 :         return result;
    7863             :     }
    7864             :     else
    7865             :     {
    7866           0 :         elog(ERROR, "bogus varno: %d", varno);
    7867             :         return NULL;            /* keep compiler quiet */
    7868             :     }
    7869             : 
    7870         168 :     if (attnum == InvalidAttrNumber)
    7871             :     {
    7872             :         /* Var is whole-row reference to RTE, so select the right field */
    7873          24 :         return get_rte_attribute_name(rte, fieldno);
    7874             :     }
    7875             : 
    7876             :     /*
    7877             :      * This part has essentially the same logic as the parser's
    7878             :      * expandRecordVariable() function, but we are dealing with a different
    7879             :      * representation of the input context, and we only need one field name
    7880             :      * not a TupleDesc.  Also, we need special cases for finding subquery and
    7881             :      * CTE subplans when deparsing Plan trees.
    7882             :      */
    7883         144 :     expr = (Node *) var;        /* default if we can't drill down */
    7884             : 
    7885         144 :     switch (rte->rtekind)
    7886             :     {
    7887           0 :         case RTE_RELATION:
    7888             :         case RTE_VALUES:
    7889             :         case RTE_NAMEDTUPLESTORE:
    7890             :         case RTE_RESULT:
    7891             : 
    7892             :             /*
    7893             :              * This case should not occur: a column of a table, values list,
    7894             :              * or ENR shouldn't have type RECORD.  Fall through and fail (most
    7895             :              * likely) at the bottom.
    7896             :              */
    7897           0 :             break;
    7898          72 :         case RTE_SUBQUERY:
    7899             :             /* Subselect-in-FROM: examine sub-select's output expr */
    7900             :             {
    7901          72 :                 if (rte->subquery)
    7902             :                 {
    7903          42 :                     TargetEntry *ste = get_tle_by_resno(rte->subquery->targetList,
    7904             :                                                         attnum);
    7905             : 
    7906          42 :                     if (ste == NULL || ste->resjunk)
    7907           0 :                         elog(ERROR, "subquery %s does not have attribute %d",
    7908             :                              rte->eref->aliasname, attnum);
    7909          42 :                     expr = (Node *) ste->expr;
    7910          42 :                     if (IsA(expr, Var))
    7911             :                     {
    7912             :                         /*
    7913             :                          * Recurse into the sub-select to see what its Var
    7914             :                          * refers to. We have to build an additional level of
    7915             :                          * namespace to keep in step with varlevelsup in the
    7916             :                          * subselect; furthermore, the subquery RTE might be
    7917             :                          * from an outer query level, in which case the
    7918             :                          * namespace for the subselect must have that outer
    7919             :                          * level as parent namespace.
    7920             :                          */
    7921          18 :                         List       *save_nslist = context->namespaces;
    7922             :                         List       *parent_namespaces;
    7923             :                         deparse_namespace mydpns;
    7924             :                         const char *result;
    7925             : 
    7926          18 :                         parent_namespaces = list_copy_tail(context->namespaces,
    7927             :                                                            netlevelsup);
    7928             : 
    7929          18 :                         set_deparse_for_query(&mydpns, rte->subquery,
    7930             :                                               parent_namespaces);
    7931             : 
    7932          18 :                         context->namespaces = lcons(&mydpns, parent_namespaces);
    7933             : 
    7934          18 :                         result = get_name_for_var_field((Var *) expr, fieldno,
    7935             :                                                         0, context);
    7936             : 
    7937          18 :                         context->namespaces = save_nslist;
    7938             : 
    7939          18 :                         return result;
    7940             :                     }
    7941             :                     /* else fall through to inspect the expression */
    7942             :                 }
    7943             :                 else
    7944             :                 {
    7945             :                     /*
    7946             :                      * We're deparsing a Plan tree so we don't have complete
    7947             :                      * RTE entries (in particular, rte->subquery is NULL). But
    7948             :                      * the only place we'd normally see a Var directly
    7949             :                      * referencing a SUBQUERY RTE is in a SubqueryScan plan
    7950             :                      * node, and we can look into the child plan's tlist
    7951             :                      * instead.  An exception occurs if the subquery was
    7952             :                      * proven empty and optimized away: then we'd find such a
    7953             :                      * Var in a childless Result node, and there's nothing in
    7954             :                      * the plan tree that would let us figure out what it had
    7955             :                      * originally referenced.  In that case, fall back on
    7956             :                      * printing "fN", analogously to the default column names
    7957             :                      * for RowExprs.
    7958             :                      */
    7959             :                     TargetEntry *tle;
    7960             :                     deparse_namespace save_dpns;
    7961             :                     const char *result;
    7962             : 
    7963          30 :                     if (!dpns->inner_plan)
    7964             :                     {
    7965          12 :                         char       *dummy_name = palloc(32);
    7966             : 
    7967             :                         Assert(dpns->plan && IsA(dpns->plan, Result));
    7968          12 :                         snprintf(dummy_name, 32, "f%d", fieldno);
    7969          12 :                         return dummy_name;
    7970             :                     }
    7971             :                     Assert(dpns->plan && IsA(dpns->plan, SubqueryScan));
    7972             : 
    7973          18 :                     tle = get_tle_by_resno(dpns->inner_tlist, attnum);
    7974          18 :                     if (!tle)
    7975           0 :                         elog(ERROR, "bogus varattno for subquery var: %d",
    7976             :                              attnum);
    7977             :                     Assert(netlevelsup == 0);
    7978          18 :                     push_child_plan(dpns, dpns->inner_plan, &save_dpns);
    7979             : 
    7980          18 :                     result = get_name_for_var_field((Var *) tle->expr, fieldno,
    7981             :                                                     levelsup, context);
    7982             : 
    7983          18 :                     pop_child_plan(dpns, &save_dpns);
    7984          18 :                     return result;
    7985             :                 }
    7986             :             }
    7987          24 :             break;
    7988           0 :         case RTE_JOIN:
    7989             :             /* Join RTE --- recursively inspect the alias variable */
    7990           0 :             if (rte->joinaliasvars == NIL)
    7991           0 :                 elog(ERROR, "cannot decompile join alias var in plan tree");
    7992             :             Assert(attnum > 0 && attnum <= list_length(rte->joinaliasvars));
    7993           0 :             expr = (Node *) list_nth(rte->joinaliasvars, attnum - 1);
    7994             :             Assert(expr != NULL);
    7995             :             /* we intentionally don't strip implicit coercions here */
    7996           0 :             if (IsA(expr, Var))
    7997           0 :                 return get_name_for_var_field((Var *) expr, fieldno,
    7998           0 :                                               var->varlevelsup + levelsup,
    7999             :                                               context);
    8000             :             /* else fall through to inspect the expression */
    8001           0 :             break;
    8002           0 :         case RTE_FUNCTION:
    8003             :         case RTE_TABLEFUNC:
    8004             : 
    8005             :             /*
    8006             :              * We couldn't get here unless a function is declared with one of
    8007             :              * its result columns as RECORD, which is not allowed.
    8008             :              */
    8009           0 :             break;
    8010          72 :         case RTE_CTE:
    8011             :             /* CTE reference: examine subquery's output expr */
    8012             :             {
    8013          72 :                 CommonTableExpr *cte = NULL;
    8014             :                 Index       ctelevelsup;
    8015             :                 ListCell   *lc;
    8016             : 
    8017             :                 /*
    8018             :                  * Try to find the referenced CTE using the namespace stack.
    8019             :                  */
    8020          72 :                 ctelevelsup = rte->ctelevelsup + netlevelsup;
    8021          72 :                 if (ctelevelsup >= list_length(context->namespaces))
    8022          12 :                     lc = NULL;
    8023             :                 else
    8024             :                 {
    8025             :                     deparse_namespace *ctedpns;
    8026             : 
    8027             :                     ctedpns = (deparse_namespace *)
    8028          60 :                         list_nth(context->namespaces, ctelevelsup);
    8029          66 :                     foreach(lc, ctedpns->ctes)
    8030             :                     {
    8031          36 :                         cte = (CommonTableExpr *) lfirst(lc);
    8032          36 :                         if (strcmp(cte->ctename, rte->ctename) == 0)
    8033          30 :                             break;
    8034             :                     }
    8035             :                 }
    8036          72 :                 if (lc != NULL)
    8037             :                 {
    8038          30 :                     Query      *ctequery = (Query *) cte->ctequery;
    8039          30 :                     TargetEntry *ste = get_tle_by_resno(GetCTETargetList(cte),
    8040             :                                                         attnum);
    8041             : 
    8042          30 :                     if (ste == NULL || ste->resjunk)
    8043           0 :                         elog(ERROR, "CTE %s does not have attribute %d",
    8044             :                              rte->eref->aliasname, attnum);
    8045          30 :                     expr = (Node *) ste->expr;
    8046          30 :                     if (IsA(expr, Var))
    8047             :                     {
    8048             :                         /*
    8049             :                          * Recurse into the CTE to see what its Var refers to.
    8050             :                          * We have to build an additional level of namespace
    8051             :                          * to keep in step with varlevelsup in the CTE;
    8052             :                          * furthermore it could be an outer CTE (compare
    8053             :                          * SUBQUERY case above).
    8054             :                          */
    8055          18 :                         List       *save_nslist = context->namespaces;
    8056             :                         List       *parent_namespaces;
    8057             :                         deparse_namespace mydpns;
    8058             :                         const char *result;
    8059             : 
    8060          18 :                         parent_namespaces = list_copy_tail(context->namespaces,
    8061             :                                                            ctelevelsup);
    8062             : 
    8063          18 :                         set_deparse_for_query(&mydpns, ctequery,
    8064             :                                               parent_namespaces);
    8065             : 
    8066          18 :                         context->namespaces = lcons(&mydpns, parent_namespaces);
    8067             : 
    8068          18 :                         result = get_name_for_var_field((Var *) expr, fieldno,
    8069             :                                                         0, context);
    8070             : 
    8071          18 :                         context->namespaces = save_nslist;
    8072             : 
    8073          18 :                         return result;
    8074             :                     }
    8075             :                     /* else fall through to inspect the expression */
    8076             :                 }
    8077             :                 else
    8078             :                 {
    8079             :                     /*
    8080             :                      * We're deparsing a Plan tree so we don't have a CTE
    8081             :                      * list.  But the only places we'd normally see a Var
    8082             :                      * directly referencing a CTE RTE are in CteScan or
    8083             :                      * WorkTableScan plan nodes.  For those cases,
    8084             :                      * set_deparse_plan arranged for dpns->inner_plan to be
    8085             :                      * the plan node that emits the CTE or RecursiveUnion
    8086             :                      * result, and we can look at its tlist instead.  As
    8087             :                      * above, this can fail if the CTE has been proven empty,
    8088             :                      * in which case fall back to "fN".
    8089             :                      */
    8090             :                     TargetEntry *tle;
    8091             :                     deparse_namespace save_dpns;
    8092             :                     const char *result;
    8093             : 
    8094          42 :                     if (!dpns->inner_plan)
    8095             :                     {
    8096           6 :                         char       *dummy_name = palloc(32);
    8097             : 
    8098             :                         Assert(dpns->plan && IsA(dpns->plan, Result));
    8099           6 :                         snprintf(dummy_name, 32, "f%d", fieldno);
    8100           6 :                         return dummy_name;
    8101             :                     }
    8102             :                     Assert(dpns->plan && (IsA(dpns->plan, CteScan) ||
    8103             :                                           IsA(dpns->plan, WorkTableScan)));
    8104             : 
    8105          36 :                     tle = get_tle_by_resno(dpns->inner_tlist, attnum);
    8106          36 :                     if (!tle)
    8107           0 :                         elog(ERROR, "bogus varattno for subquery var: %d",
    8108             :                              attnum);
    8109             :                     Assert(netlevelsup == 0);
    8110          36 :                     push_child_plan(dpns, dpns->inner_plan, &save_dpns);
    8111             : 
    8112          36 :                     result = get_name_for_var_field((Var *) tle->expr, fieldno,
    8113             :                                                     levelsup, context);
    8114             : 
    8115          36 :                     pop_child_plan(dpns, &save_dpns);
    8116          36 :                     return result;
    8117             :                 }
    8118             :             }
    8119          12 :             break;
    8120             :     }
    8121             : 
    8122             :     /*
    8123             :      * We now have an expression we can't expand any more, so see if
    8124             :      * get_expr_result_tupdesc() can do anything with it.
    8125             :      */
    8126          36 :     tupleDesc = get_expr_result_tupdesc(expr, false);
    8127             :     /* Got the tupdesc, so we can extract the field name */
    8128             :     Assert(fieldno >= 1 && fieldno <= tupleDesc->natts);
    8129          36 :     return NameStr(TupleDescAttr(tupleDesc, fieldno - 1)->attname);
    8130             : }
    8131             : 
    8132             : /*
    8133             :  * Try to find the referenced expression for a PARAM_EXEC Param that might
    8134             :  * reference a parameter supplied by an upper NestLoop or SubPlan plan node.
    8135             :  *
    8136             :  * If successful, return the expression and set *dpns_p and *ancestor_cell_p
    8137             :  * appropriately for calling push_ancestor_plan().  If no referent can be
    8138             :  * found, return NULL.
    8139             :  */
    8140             : static Node *
    8141        6156 : find_param_referent(Param *param, deparse_context *context,
    8142             :                     deparse_namespace **dpns_p, ListCell **ancestor_cell_p)
    8143             : {
    8144             :     /* Initialize output parameters to prevent compiler warnings */
    8145        6156 :     *dpns_p = NULL;
    8146        6156 :     *ancestor_cell_p = NULL;
    8147             : 
    8148             :     /*
    8149             :      * If it's a PARAM_EXEC parameter, look for a matching NestLoopParam or
    8150             :      * SubPlan argument.  This will necessarily be in some ancestor of the
    8151             :      * current expression's Plan node.
    8152             :      */
    8153        6156 :     if (param->paramkind == PARAM_EXEC)
    8154             :     {
    8155             :         deparse_namespace *dpns;
    8156             :         Plan       *child_plan;
    8157             :         ListCell   *lc;
    8158             : 
    8159        5294 :         dpns = (deparse_namespace *) linitial(context->namespaces);
    8160        5294 :         child_plan = dpns->plan;
    8161             : 
    8162        9714 :         foreach(lc, dpns->ancestors)
    8163             :         {
    8164        8138 :             Node       *ancestor = (Node *) lfirst(lc);
    8165             :             ListCell   *lc2;
    8166             : 
    8167             :             /*
    8168             :              * NestLoops transmit params to their inner child only.
    8169             :              */
    8170        8138 :             if (IsA(ancestor, NestLoop) &&
    8171        3410 :                 child_plan == innerPlan(ancestor))
    8172             :             {
    8173        3332 :                 NestLoop   *nl = (NestLoop *) ancestor;
    8174             : 
    8175        4240 :                 foreach(lc2, nl->nestParams)
    8176             :                 {
    8177        4108 :                     NestLoopParam *nlp = (NestLoopParam *) lfirst(lc2);
    8178             : 
    8179        4108 :                     if (nlp->paramno == param->paramid)
    8180             :                     {
    8181             :                         /* Found a match, so return it */
    8182        3200 :                         *dpns_p = dpns;
    8183        3200 :                         *ancestor_cell_p = lc;
    8184        3200 :                         return (Node *) nlp->paramval;
    8185             :                     }
    8186             :                 }
    8187             :             }
    8188             : 
    8189             :             /*
    8190             :              * If ancestor is a SubPlan, check the arguments it provides.
    8191             :              */
    8192        4938 :             if (IsA(ancestor, SubPlan))
    8193             :             {
    8194         860 :                 SubPlan    *subplan = (SubPlan *) ancestor;
    8195             :                 ListCell   *lc3;
    8196             :                 ListCell   *lc4;
    8197             : 
    8198        1148 :                 forboth(lc3, subplan->parParam, lc4, subplan->args)
    8199             :                 {
    8200         806 :                     int         paramid = lfirst_int(lc3);
    8201         806 :                     Node       *arg = (Node *) lfirst(lc4);
    8202             : 
    8203         806 :                     if (paramid == param->paramid)
    8204             :                     {
    8205             :                         /*
    8206             :                          * Found a match, so return it.  But, since Vars in
    8207             :                          * the arg are to be evaluated in the surrounding
    8208             :                          * context, we have to point to the next ancestor item
    8209             :                          * that is *not* a SubPlan.
    8210             :                          */
    8211             :                         ListCell   *rest;
    8212             : 
    8213         518 :                         for_each_cell(rest, dpns->ancestors,
    8214             :                                       lnext(dpns->ancestors, lc))
    8215             :                         {
    8216         518 :                             Node       *ancestor2 = (Node *) lfirst(rest);
    8217             : 
    8218         518 :                             if (!IsA(ancestor2, SubPlan))
    8219             :                             {
    8220         518 :                                 *dpns_p = dpns;
    8221         518 :                                 *ancestor_cell_p = rest;
    8222         518 :                                 return arg;
    8223             :                             }
    8224             :                         }
    8225           0 :                         elog(ERROR, "SubPlan cannot be outermost ancestor");
    8226             :                     }
    8227             :                 }
    8228             : 
    8229             :                 /* SubPlan isn't a kind of Plan, so skip the rest */
    8230         342 :                 continue;
    8231             :             }
    8232             : 
    8233             :             /*
    8234             :              * We need not consider the ancestor's initPlan list, since
    8235             :              * initplans never have any parParams.
    8236             :              */
    8237             : 
    8238             :             /* No luck, crawl up to next ancestor */
    8239        4078 :             child_plan = (Plan *) ancestor;
    8240             :         }
    8241             :     }
    8242             : 
    8243             :     /* No referent found */
    8244        2438 :     return NULL;
    8245             : }
    8246             : 
    8247             : /*
    8248             :  * Try to find a subplan/initplan that emits the value for a PARAM_EXEC Param.
    8249             :  *
    8250             :  * If successful, return the generating subplan/initplan and set *column_p
    8251             :  * to the subplan's 0-based output column number.
    8252             :  * Otherwise, return NULL.
    8253             :  */
    8254             : static SubPlan *
    8255        2438 : find_param_generator(Param *param, deparse_context *context, int *column_p)
    8256             : {
    8257             :     /* Initialize output parameter to prevent compiler warnings */
    8258        2438 :     *column_p = 0;
    8259             : 
    8260             :     /*
    8261             :      * If it's a PARAM_EXEC parameter, search the current plan node as well as
    8262             :      * ancestor nodes looking for a subplan or initplan that emits the value
    8263             :      * for the Param.  It could appear in the setParams of an initplan or
    8264             :      * MULTIEXPR_SUBLINK subplan, or in the paramIds of an ancestral SubPlan.
    8265             :      */
    8266        2438 :     if (param->paramkind == PARAM_EXEC)
    8267             :     {
    8268             :         SubPlan    *result;
    8269             :         deparse_namespace *dpns;
    8270             :         ListCell   *lc;
    8271             : 
    8272        1576 :         dpns = (deparse_namespace *) linitial(context->namespaces);
    8273             : 
    8274             :         /* First check the innermost plan node's initplans */
    8275        1576 :         result = find_param_generator_initplan(param, dpns->plan, column_p);
    8276        1576 :         if (result)
    8277         452 :             return result;
    8278             : 
    8279             :         /*
    8280             :          * The plan's targetlist might contain MULTIEXPR_SUBLINK SubPlans,
    8281             :          * which can be referenced by Params elsewhere in the targetlist.
    8282             :          * (Such Params should always be in the same targetlist, so there's no
    8283             :          * need to do this work at upper plan nodes.)
    8284             :          */
    8285        5716 :         foreach_node(TargetEntry, tle, dpns->plan->targetlist)
    8286             :         {
    8287        3572 :             if (tle->expr && IsA(tle->expr, SubPlan))
    8288             :             {
    8289         100 :                 SubPlan    *subplan = (SubPlan *) tle->expr;
    8290             : 
    8291         100 :                 if (subplan->subLinkType == MULTIEXPR_SUBLINK)
    8292             :                 {
    8293          78 :                     foreach_int(paramid, subplan->setParam)
    8294             :                     {
    8295          78 :                         if (paramid == param->paramid)
    8296             :                         {
    8297             :                             /* Found a match, so return it. */
    8298          52 :                             *column_p = foreach_current_index(paramid);
    8299          52 :                             return subplan;
    8300             :                         }
    8301             :                     }
    8302             :                 }
    8303             :             }
    8304             :         }
    8305             : 
    8306             :         /* No luck, so check the ancestor nodes */
    8307        1414 :         foreach(lc, dpns->ancestors)
    8308             :         {
    8309        1414 :             Node       *ancestor = (Node *) lfirst(lc);
    8310             : 
    8311             :             /*
    8312             :              * If ancestor is a SubPlan, check the paramIds it provides.
    8313             :              */
    8314        1414 :             if (IsA(ancestor, SubPlan))
    8315             :             {
    8316         204 :                 SubPlan    *subplan = (SubPlan *) ancestor;
    8317             : 
    8318         230 :                 foreach_int(paramid, subplan->paramIds)
    8319             :                 {
    8320         230 :                     if (paramid == param->paramid)
    8321             :                     {
    8322             :                         /* Found a match, so return it. */
    8323         204 :                         *column_p = foreach_current_index(paramid);
    8324         204 :                         return subplan;
    8325             :                     }
    8326             :                 }
    8327             : 
    8328             :                 /* SubPlan isn't a kind of Plan, so skip the rest */
    8329           0 :                 continue;
    8330             :             }
    8331             : 
    8332             :             /*
    8333             :              * Otherwise, it's some kind of Plan node, so check its initplans.
    8334             :              */
    8335        1210 :             result = find_param_generator_initplan(param, (Plan *) ancestor,
    8336             :                                                    column_p);
    8337        1210 :             if (result)
    8338         868 :                 return result;
    8339             : 
    8340             :             /* No luck, crawl up to next ancestor */
    8341             :         }
    8342             :     }
    8343             : 
    8344             :     /* No generator found */
    8345         862 :     return NULL;
    8346             : }
    8347             : 
    8348             : /*
    8349             :  * Subroutine for find_param_generator: search one Plan node's initplans
    8350             :  */
    8351             : static SubPlan *
    8352        2786 : find_param_generator_initplan(Param *param, Plan *plan, int *column_p)
    8353             : {
    8354        4392 :     foreach_node(SubPlan, subplan, plan->initPlan)
    8355             :     {
    8356        1746 :         foreach_int(paramid, subplan->setParam)
    8357             :         {
    8358        1466 :             if (paramid == param->paramid)
    8359             :             {
    8360             :                 /* Found a match, so return it. */
    8361        1320 :                 *column_p = foreach_current_index(paramid);
    8362        1320 :                 return subplan;
    8363             :             }
    8364             :         }
    8365             :     }
    8366        1466 :     return NULL;
    8367             : }
    8368             : 
    8369             : /*
    8370             :  * Display a Param appropriately.
    8371             :  */
    8372             : static void
    8373        6138 : get_parameter(Param *param, deparse_context *context)
    8374             : {
    8375             :     Node       *expr;
    8376             :     deparse_namespace *dpns;
    8377             :     ListCell   *ancestor_cell;
    8378             :     SubPlan    *subplan;
    8379             :     int         column;
    8380             : 
    8381             :     /*
    8382             :      * If it's a PARAM_EXEC parameter, try to locate the expression from which
    8383             :      * the parameter was computed.  This stanza handles only cases in which
    8384             :      * the Param represents an input to the subplan we are currently in.
    8385             :      */
    8386        6138 :     expr = find_param_referent(param, context, &dpns, &ancestor_cell);
    8387        6138 :     if (expr)
    8388             :     {
    8389             :         /* Found a match, so print it */
    8390             :         deparse_namespace save_dpns;
    8391             :         bool        save_varprefix;
    8392             :         bool        need_paren;
    8393             : 
    8394             :         /* Switch attention to the ancestor plan node */
    8395        3700 :         push_ancestor_plan(dpns, ancestor_cell, &save_dpns);
    8396             : 
    8397             :         /*
    8398             :          * Force prefixing of Vars, since they won't belong to the relation
    8399             :          * being scanned in the original plan node.
    8400             :          */
    8401        3700 :         save_varprefix = context->varprefix;
    8402        3700 :         context->varprefix = true;
    8403             : 
    8404             :         /*
    8405             :          * A Param's expansion is typically a Var, Aggref, GroupingFunc, or
    8406             :          * upper-level Param, which wouldn't need extra parentheses.
    8407             :          * Otherwise, insert parens to ensure the expression looks atomic.
    8408             :          */
    8409        3706 :         need_paren = !(IsA(expr, Var) ||
    8410           6 :                        IsA(expr, Aggref) ||
    8411           6 :                        IsA(expr, GroupingFunc) ||
    8412           0 :                        IsA(expr, Param));
    8413        3700 :         if (need_paren)
    8414           0 :             appendStringInfoChar(context->buf, '(');
    8415             : 
    8416        3700 :         get_rule_expr(expr, context, false);
    8417             : 
    8418        3700 :         if (need_paren)
    8419           0 :             appendStringInfoChar(context->buf, ')');
    8420             : 
    8421        3700 :         context->varprefix = save_varprefix;
    8422             : 
    8423        3700 :         pop_ancestor_plan(dpns, &save_dpns);
    8424             : 
    8425        3700 :         return;
    8426             :     }
    8427             : 
    8428             :     /*
    8429             :      * Alternatively, maybe it's a subplan output, which we print as a
    8430             :      * reference to the subplan.  (We could drill down into the subplan and
    8431             :      * print the relevant targetlist expression, but that has been deemed too
    8432             :      * confusing since it would violate normal SQL scope rules.  Also, we're
    8433             :      * relying on this reference to show that the testexpr containing the
    8434             :      * Param has anything to do with that subplan at all.)
    8435             :      */
    8436        2438 :     subplan = find_param_generator(param, context, &column);
    8437        2438 :     if (subplan)
    8438             :     {
    8439        1576 :         appendStringInfo(context->buf, "(%s%s).col%d",
    8440        1576 :                          subplan->useHashTable ? "hashed " : "",
    8441             :                          subplan->plan_name, column + 1);
    8442             : 
    8443        1576 :         return;
    8444             :     }
    8445             : 
    8446             :     /*
    8447             :      * If it's an external parameter, see if the outermost namespace provides
    8448             :      * function argument names.
    8449             :      */
    8450         862 :     if (param->paramkind == PARAM_EXTERN && context->namespaces != NIL)
    8451             :     {
    8452         862 :         dpns = llast(context->namespaces);
    8453         862 :         if (dpns->argnames &&
    8454          68 :             param->paramid > 0 &&
    8455          68 :             param->paramid <= dpns->numargs)
    8456             :         {
    8457          68 :             char       *argname = dpns->argnames[param->paramid - 1];
    8458             : 
    8459          68 :             if (argname)
    8460             :             {
    8461          68 :                 bool        should_qualify = false;
    8462             :                 ListCell   *lc;
    8463             : 
    8464             :                 /*
    8465             :                  * Qualify the parameter name if there are any other deparse
    8466             :                  * namespaces with range tables.  This avoids qualifying in
    8467             :                  * trivial cases like "RETURN a + b", but makes it safe in all
    8468             :                  * other cases.
    8469             :                  */
    8470         156 :                 foreach(lc, context->namespaces)
    8471             :                 {
    8472         118 :                     deparse_namespace *depns = lfirst(lc);
    8473             : 
    8474         118 :                     if (depns->rtable_names != NIL)
    8475             :                     {
    8476          30 :                         should_qualify = true;
    8477          30 :                         break;
    8478             :                     }
    8479             :                 }
    8480          68 :                 if (should_qualify)
    8481             :                 {
    8482          30 :                     appendStringInfoString(context->buf, quote_identifier(dpns->funcname));
    8483          30 :                     appendStringInfoChar(context->buf, '.');
    8484             :                 }
    8485             : 
    8486          68 :                 appendStringInfoString(context->buf, quote_identifier(argname));
    8487          68 :                 return;
    8488             :             }
    8489             :         }
    8490             :     }
    8491             : 
    8492             :     /*
    8493             :      * Not PARAM_EXEC, or couldn't find referent: just print $N.
    8494             :      *
    8495             :      * It's a bug if we get here for anything except PARAM_EXTERN Params, but
    8496             :      * in production builds printing $N seems more useful than failing.
    8497             :      */
    8498             :     Assert(param->paramkind == PARAM_EXTERN);
    8499             : 
    8500         794 :     appendStringInfo(context->buf, "$%d", param->paramid);
    8501             : }
    8502             : 
    8503             : /*
    8504             :  * get_simple_binary_op_name
    8505             :  *
    8506             :  * helper function for isSimpleNode
    8507             :  * will return single char binary operator name, or NULL if it's not
    8508             :  */
    8509             : static const char *
    8510         114 : get_simple_binary_op_name(OpExpr *expr)
    8511             : {
    8512         114 :     List       *args = expr->args;
    8513             : 
    8514         114 :     if (list_length(args) == 2)
    8515             :     {
    8516             :         /* binary operator */
    8517         114 :         Node       *arg1 = (Node *) linitial(args);
    8518         114 :         Node       *arg2 = (Node *) lsecond(args);
    8519             :         const char *op;
    8520             : 
    8521         114 :         op = generate_operator_name(expr->opno, exprType(arg1), exprType(arg2));
    8522         114 :         if (strlen(op) == 1)
    8523         114 :             return op;
    8524             :     }
    8525           0 :     return NULL;
    8526             : }
    8527             : 
    8528             : 
    8529             : /*
    8530             :  * isSimpleNode - check if given node is simple (doesn't need parenthesizing)
    8531             :  *
    8532             :  *  true   : simple in the context of parent node's type
    8533             :  *  false  : not simple
    8534             :  */
    8535             : static bool
    8536        4832 : isSimpleNode(Node *node, Node *parentNode, int prettyFlags)
    8537             : {
    8538        4832 :     if (!node)
    8539           0 :         return false;
    8540             : 
    8541        4832 :     switch (nodeTag(node))
    8542             :     {
    8543        4064 :         case T_Var:
    8544             :         case T_Const:
    8545             :         case T_Param:
    8546             :         case T_CoerceToDomainValue:
    8547             :         case T_SetToDefault:
    8548             :         case T_CurrentOfExpr:
    8549             :             /* single words: always simple */
    8550        4064 :             return true;
    8551             : 
    8552         402 :         case T_SubscriptingRef:
    8553             :         case T_ArrayExpr:
    8554             :         case T_RowExpr:
    8555             :         case T_CoalesceExpr:
    8556             :         case T_MinMaxExpr:
    8557             :         case T_SQLValueFunction:
    8558             :         case T_XmlExpr:
    8559             :         case T_NextValueExpr:
    8560             :         case T_NullIfExpr:
    8561             :         case T_Aggref:
    8562             :         case T_GroupingFunc:
    8563             :         case T_WindowFunc:
    8564             :         case T_MergeSupportFunc:
    8565             :         case T_FuncExpr:
    8566             :         case T_JsonConstructorExpr:
    8567             :         case T_JsonExpr:
    8568             :             /* function-like: name(..) or name[..] */
    8569         402 :             return true;
    8570             : 
    8571             :             /* CASE keywords act as parentheses */
    8572           0 :         case T_CaseExpr:
    8573           0 :             return true;
    8574             : 
    8575          54 :         case T_FieldSelect:
    8576             : 
    8577             :             /*
    8578             :              * appears simple since . has top precedence, unless parent is
    8579             :              * T_FieldSelect itself!
    8580             :              */
    8581          54 :             return !IsA(parentNode, FieldSelect);
    8582             : 
    8583           0 :         case T_FieldStore:
    8584             : 
    8585             :             /*
    8586             :              * treat like FieldSelect (probably doesn't matter)
    8587             :              */
    8588           0 :             return !IsA(parentNode, FieldStore);
    8589             : 
    8590           0 :         case T_CoerceToDomain:
    8591             :             /* maybe simple, check args */
    8592           0 :             return isSimpleNode((Node *) ((CoerceToDomain *) node)->arg,
    8593             :                                 node, prettyFlags);
    8594           6 :         case T_RelabelType:
    8595           6 :             return isSimpleNode((Node *) ((RelabelType *) node)->arg,
    8596             :                                 node, prettyFlags);
    8597           0 :         case T_CoerceViaIO:
    8598           0 :             return isSimpleNode((Node *) ((CoerceViaIO *) node)->arg,
    8599             :                                 node, prettyFlags);
    8600           0 :         case T_ArrayCoerceExpr:
    8601           0 :             return isSimpleNode((Node *) ((ArrayCoerceExpr *) node)->arg,
    8602             :                                 node, prettyFlags);
    8603           0 :         case T_ConvertRowtypeExpr:
    8604           0 :             return isSimpleNode((Node *) ((ConvertRowtypeExpr *) node)->arg,
    8605             :                                 node, prettyFlags);
    8606             : 
    8607         252 :         case T_OpExpr:
    8608             :             {
    8609             :                 /* depends on parent node type; needs further checking */
    8610         252 :                 if (prettyFlags & PRETTYFLAG_PAREN && IsA(parentNode, OpExpr))
    8611             :                 {
    8612             :                     const char *op;
    8613             :                     const char *parentOp;
    8614             :                     bool        is_lopriop;
    8615             :                     bool        is_hipriop;
    8616             :                     bool        is_lopriparent;
    8617             :                     bool        is_hipriparent;
    8618             : 
    8619          60 :                     op = get_simple_binary_op_name((OpExpr *) node);
    8620          60 :                     if (!op)
    8621           0 :                         return false;
    8622             : 
    8623             :                     /* We know only the basic operators + - and * / % */
    8624          60 :                     is_lopriop = (strchr("+-", *op) != NULL);
    8625          60 :                     is_hipriop = (strchr("*/%", *op) != NULL);
    8626          60 :                     if (!(is_lopriop || is_hipriop))
    8627           6 :                         return false;
    8628             : 
    8629          54 :                     parentOp = get_simple_binary_op_name((OpExpr *) parentNode);
    8630          54 :                     if (!parentOp)
    8631           0 :                         return false;
    8632             : 
    8633          54 :                     is_lopriparent = (strchr("+-", *parentOp) != NULL);
    8634          54 :                     is_hipriparent = (strchr("*/%", *parentOp) != NULL);
    8635          54 :                     if (!(is_lopriparent || is_hipriparent))
    8636           0 :                         return false;
    8637             : 
    8638          54 :                     if (is_hipriop && is_lopriparent)
    8639          12 :                         return true;    /* op binds tighter than parent */
    8640             : 
    8641          42 :                     if (is_lopriop && is_hipriparent)
    8642          30 :                         return false;
    8643             : 
    8644             :                     /*
    8645             :                      * Operators are same priority --- can skip parens only if
    8646             :                      * we have (a - b) - c, not a - (b - c).
    8647             :                      */
    8648          12 :                     if (node == (Node *) linitial(((OpExpr *) parentNode)->args))
    8649           6 :                         return true;
    8650             : 
    8651           6 :                     return false;
    8652             :                 }
    8653             :                 /* else do the same stuff as for T_SubLink et al. */
    8654             :             }
    8655             :             /* FALLTHROUGH */
    8656             : 
    8657             :         case T_SubLink:
    8658             :         case T_NullTest:
    8659             :         case T_BooleanTest:
    8660             :         case T_DistinctExpr:
    8661             :         case T_JsonIsPredicate:
    8662         222 :             switch (nodeTag(parentNode))
    8663             :             {
    8664          30 :                 case T_FuncExpr:
    8665             :                     {
    8666             :                         /* special handling for casts and COERCE_SQL_SYNTAX */
    8667          30 :                         CoercionForm type = ((FuncExpr *) parentNode)->funcformat;
    8668             : 
    8669          30 :                         if (type == COERCE_EXPLICIT_CAST ||
    8670           6 :                             type == COERCE_IMPLICIT_CAST ||
    8671             :                             type == COERCE_SQL_SYNTAX)
    8672          30 :                             return false;
    8673           0 :                         return true;    /* own parentheses */
    8674             :                     }
    8675         162 :                 case T_BoolExpr:    /* lower precedence */
    8676             :                 case T_SubscriptingRef: /* other separators */
    8677             :                 case T_ArrayExpr:   /* other separators */
    8678             :                 case T_RowExpr: /* other separators */
    8679             :                 case T_CoalesceExpr:    /* own parentheses */
    8680             :                 case T_MinMaxExpr:  /* own parentheses */
    8681             :                 case T_XmlExpr: /* own parentheses */
    8682             :                 case T_NullIfExpr:  /* other separators */
    8683             :                 case T_Aggref:  /* own parentheses */
    8684             :                 case T_GroupingFunc:    /* own parentheses */
    8685             :                 case T_WindowFunc:  /* own parentheses */
    8686             :                 case T_CaseExpr:    /* other separators */
    8687         162 :                     return true;
    8688          30 :                 default:
    8689          30 :                     return false;
    8690             :             }
    8691             : 
    8692          18 :         case T_BoolExpr:
    8693          18 :             switch (nodeTag(parentNode))
    8694             :             {
    8695          18 :                 case T_BoolExpr:
    8696          18 :                     if (prettyFlags & PRETTYFLAG_PAREN)
    8697             :                     {
    8698             :                         BoolExprType type;
    8699             :                         BoolExprType parentType;
    8700             : 
    8701          18 :                         type = ((BoolExpr *) node)->boolop;
    8702          18 :                         parentType = ((BoolExpr *) parentNode)->boolop;
    8703             :                         switch (type)
    8704             :                         {
    8705          12 :                             case NOT_EXPR:
    8706             :                             case AND_EXPR:
    8707          12 :                                 if (parentType == AND_EXPR || parentType == OR_EXPR)
    8708          12 :                                     return true;
    8709           0 :                                 break;
    8710           6 :                             case OR_EXPR:
    8711           6 :                                 if (parentType == OR_EXPR)
    8712           0 :                                     return true;
    8713           6 :                                 break;
    8714             :                         }
    8715           0 :                     }
    8716           6 :                     return false;
    8717           0 :                 case T_FuncExpr:
    8718             :                     {
    8719             :                         /* special handling for casts and COERCE_SQL_SYNTAX */
    8720           0 :                         CoercionForm type = ((FuncExpr *) parentNode)->funcformat;
    8721             : 
    8722           0 :                         if (type == COERCE_EXPLICIT_CAST ||
    8723           0 :                             type == COERCE_IMPLICIT_CAST ||
    8724             :                             type == COERCE_SQL_SYNTAX)
    8725           0 :                             return false;
    8726           0 :                         return true;    /* own parentheses */
    8727             :                     }
    8728           0 :                 case T_SubscriptingRef: /* other separators */
    8729             :                 case T_ArrayExpr:   /* other separators */
    8730             :                 case T_RowExpr: /* other separators */
    8731             :                 case T_CoalesceExpr:    /* own parentheses */
    8732             :                 case T_MinMaxExpr:  /* own parentheses */
    8733             :                 case T_XmlExpr: /* own parentheses */
    8734             :                 case T_NullIfExpr:  /* other separators */
    8735             :                 case T_Aggref:  /* own parentheses */
    8736             :                 case T_GroupingFunc:    /* own parentheses */
    8737             :                 case T_WindowFunc:  /* own parentheses */
    8738             :                 case T_CaseExpr:    /* other separators */
    8739             :                 case T_JsonExpr:    /* own parentheses */
    8740           0 :                     return true;
    8741           0 :                 default:
    8742           0 :                     return false;
    8743             :             }
    8744             : 
    8745           0 :         case T_JsonValueExpr:
    8746             :             /* maybe simple, check args */
    8747           0 :             return isSimpleNode((Node *) ((JsonValueExpr *) node)->raw_expr,
    8748             :                                 node, prettyFlags);
    8749             : 
    8750           6 :         default:
    8751           6 :             break;
    8752             :     }
    8753             :     /* those we don't know: in dubio complexo */
    8754           6 :     return false;
    8755             : }
    8756             : 
    8757             : 
    8758             : /*
    8759             :  * appendContextKeyword - append a keyword to buffer
    8760             :  *
    8761             :  * If prettyPrint is enabled, perform a line break, and adjust indentation.
    8762             :  * Otherwise, just append the keyword.
    8763             :  */
    8764             : static void
    8765       28464 : appendContextKeyword(deparse_context *context, const char *str,
    8766             :                      int indentBefore, int indentAfter, int indentPlus)
    8767             : {
    8768       28464 :     StringInfo  buf = context->buf;
    8769             : 
    8770       28464 :     if (PRETTY_INDENT(context))
    8771             :     {
    8772             :         int         indentAmount;
    8773             : 
    8774       27692 :         context->indentLevel += indentBefore;
    8775             : 
    8776             :         /* remove any trailing spaces currently in the buffer ... */
    8777       27692 :         removeStringInfoSpaces(buf);
    8778             :         /* ... then add a newline and some spaces */
    8779       27692 :         appendStringInfoChar(buf, '\n');
    8780             : 
    8781       27692 :         if (context->indentLevel < PRETTYINDENT_LIMIT)
    8782       27692 :             indentAmount = Max(context->indentLevel, 0) + indentPlus;
    8783             :         else
    8784             :         {
    8785             :             /*
    8786             :              * If we're indented more than PRETTYINDENT_LIMIT characters, try
    8787             :              * to conserve horizontal space by reducing the per-level
    8788             :              * indentation.  For best results the scale factor here should
    8789             :              * divide all the indent amounts that get added to indentLevel
    8790             :              * (PRETTYINDENT_STD, etc).  It's important that the indentation
    8791             :              * not grow unboundedly, else deeply-nested trees use O(N^2)
    8792             :              * whitespace; so we also wrap modulo PRETTYINDENT_LIMIT.
    8793             :              */
    8794           0 :             indentAmount = PRETTYINDENT_LIMIT +
    8795           0 :                 (context->indentLevel - PRETTYINDENT_LIMIT) /
    8796             :                 (PRETTYINDENT_STD / 2);
    8797           0 :             indentAmount %= PRETTYINDENT_LIMIT;
    8798             :             /* scale/wrap logic affects indentLevel, but not indentPlus */
    8799           0 :             indentAmount += indentPlus;
    8800             :         }
    8801       27692 :         appendStringInfoSpaces(buf, indentAmount);
    8802             : 
    8803       27692 :         appendStringInfoString(buf, str);
    8804             : 
    8805       27692 :         context->indentLevel += indentAfter;
    8806       27692 :         if (context->indentLevel < 0)
    8807           0 :             context->indentLevel = 0;
    8808             :     }
    8809             :     else
    8810         772 :         appendStringInfoString(buf, str);
    8811       28464 : }
    8812             : 
    8813             : /*
    8814             :  * removeStringInfoSpaces - delete trailing spaces from a buffer.
    8815             :  *
    8816             :  * Possibly this should move to stringinfo.c at some point.
    8817             :  */
    8818             : static void
    8819       28154 : removeStringInfoSpaces(StringInfo str)
    8820             : {
    8821       43956 :     while (str->len > 0 && str->data[str->len - 1] == ' ')
    8822       15802 :         str->data[--(str->len)] = '\0';
    8823       28154 : }
    8824             : 
    8825             : 
    8826             : /*
    8827             :  * get_rule_expr_paren  - deparse expr using get_rule_expr,
    8828             :  * embracing the string with parentheses if necessary for prettyPrint.
    8829             :  *
    8830             :  * Never embrace if prettyFlags=0, because it's done in the calling node.
    8831             :  *
    8832             :  * Any node that does *not* embrace its argument node by sql syntax (with
    8833             :  * parentheses, non-operator keywords like CASE/WHEN/ON, or comma etc) should
    8834             :  * use get_rule_expr_paren instead of get_rule_expr so parentheses can be
    8835             :  * added.
    8836             :  */
    8837             : static void
    8838      146804 : get_rule_expr_paren(Node *node, deparse_context *context,
    8839             :                     bool showimplicit, Node *parentNode)
    8840             : {
    8841             :     bool        need_paren;
    8842             : 
    8843      151630 :     need_paren = PRETTY_PAREN(context) &&
    8844        4826 :         !isSimpleNode(node, parentNode, context->prettyFlags);
    8845             : 
    8846      146804 :     if (need_paren)
    8847         114 :         appendStringInfoChar(context->buf, '(');
    8848             : 
    8849      146804 :     get_rule_expr(node, context, showimplicit);
    8850             : 
    8851      146804 :     if (need_paren)
    8852         114 :         appendStringInfoChar(context->buf, ')');
    8853      146804 : }
    8854             : 
    8855             : static void
    8856          84 : get_json_behavior(JsonBehavior *behavior, deparse_context *context,
    8857             :                   const char *on)
    8858             : {
    8859             :     /*
    8860             :      * The order of array elements must correspond to the order of
    8861             :      * JsonBehaviorType members.
    8862             :      */
    8863          84 :     const char *behavior_names[] =
    8864             :     {
    8865             :         " NULL",
    8866             :         " ERROR",
    8867             :         " EMPTY",
    8868             :         " TRUE",
    8869             :         " FALSE",
    8870             :         " UNKNOWN",
    8871             :         " EMPTY ARRAY",
    8872             :         " EMPTY OBJECT",
    8873             :         " DEFAULT "
    8874             :     };
    8875             : 
    8876          84 :     if ((int) behavior->btype < 0 || behavior->btype >= lengthof(behavior_names))
    8877           0 :         elog(ERROR, "invalid json behavior type: %d", behavior->btype);
    8878             : 
    8879          84 :     appendStringInfoString(context->buf, behavior_names[behavior->btype]);
    8880             : 
    8881          84 :     if (behavior->btype == JSON_BEHAVIOR_DEFAULT)
    8882          18 :         get_rule_expr(behavior->expr, context, false);
    8883             : 
    8884          84 :     appendStringInfo(context->buf, " ON %s", on);
    8885          84 : }
    8886             : 
    8887             : /*
    8888             :  * get_json_expr_options
    8889             :  *
    8890             :  * Parse back common options for JSON_QUERY, JSON_VALUE, JSON_EXISTS and
    8891             :  * JSON_TABLE columns.
    8892             :  */
    8893             : static void
    8894         456 : get_json_expr_options(JsonExpr *jsexpr, deparse_context *context,
    8895             :                       JsonBehaviorType default_behavior)
    8896             : {
    8897         456 :     if (jsexpr->op == JSON_QUERY_OP)
    8898             :     {
    8899         210 :         if (jsexpr->wrapper == JSW_CONDITIONAL)
    8900          12 :             appendStringInfoString(context->buf, " WITH CONDITIONAL WRAPPER");
    8901         198 :         else if (jsexpr->wrapper == JSW_UNCONDITIONAL)
    8902          30 :             appendStringInfoString(context->buf, " WITH UNCONDITIONAL WRAPPER");
    8903             :         /* The default */
    8904         168 :         else if (jsexpr->wrapper == JSW_NONE || jsexpr->wrapper == JSW_UNSPEC)
    8905         168 :             appendStringInfoString(context->buf, " WITHOUT WRAPPER");
    8906             : 
    8907         210 :         if (jsexpr->omit_quotes)
    8908          42 :             appendStringInfoString(context->buf, " OMIT QUOTES");
    8909             :         /* The default */
    8910             :         else
    8911         168 :             appendStringInfoString(context->buf, " KEEP QUOTES");
    8912             :     }
    8913             : 
    8914         456 :     if (jsexpr->on_empty && jsexpr->on_empty->btype != default_behavior)
    8915          30 :         get_json_behavior(jsexpr->on_empty, context, "EMPTY");
    8916             : 
    8917