/*-------------------------------------------------------------------------

 *

 * ruleutils.c

 *    Functions to convert stored expressions/querytrees back to

 *    source text

 *

 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group

 * Portions Copyright (c) 1994, Regents of the University of California

 *

 *

 * IDENTIFICATION

 *    src/backend/utils/adt/ruleutils.c

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include <ctype.h>

#include <unistd.h>

#include <fcntl.h>

#include "access/amapi.h"

#include "access/htup_details.h"

#include "access/relation.h"

#include "access/table.h"

#include "catalog/pg_aggregate.h"

#include "catalog/pg_am.h"

#include "catalog/pg_authid.h"

#include "catalog/pg_collation.h"

#include "catalog/pg_constraint.h"

#include "catalog/pg_depend.h"

#include "catalog/pg_language.h"

#include "catalog/pg_opclass.h"

#include "catalog/pg_operator.h"

#include "catalog/pg_partitioned_table.h"

#include "catalog/pg_proc.h"

#include "catalog/pg_statistic_ext.h"

#include "catalog/pg_trigger.h"

#include "catalog/pg_type.h"

#include "commands/defrem.h"

#include "commands/tablespace.h"

#include "common/keywords.h"

#include "executor/spi.h"

#include "funcapi.h"

#include "mb/pg_wchar.h"

#include "miscadmin.h"

#include "nodes/makefuncs.h"

#include "nodes/nodeFuncs.h"

#include "nodes/pathnodes.h"

#include "optimizer/optimizer.h"

#include "parser/parse_agg.h"

#include "parser/parse_func.h"

#include "parser/parse_oper.h"

#include "parser/parse_relation.h"

#include "parser/parser.h"

#include "parser/parsetree.h"

#include "rewrite/rewriteHandler.h"

#include "rewrite/rewriteManip.h"

#include "rewrite/rewriteSupport.h"

#include "utils/array.h"

#include "utils/builtins.h"

#include "utils/fmgroids.h"

#include "utils/guc.h"

#include "utils/hsearch.h"

#include "utils/lsyscache.h"

#include "utils/partcache.h"

#include "utils/rel.h"

#include "utils/ruleutils.h"

#include "utils/snapmgr.h"

#include "utils/syscache.h"

#include "utils/typcache.h"

#include "utils/varlena.h"

#include "utils/xml.h"

/* ----------

 * Pretty formatting constants

 * ----------

 */

/* Indent counts */

#define PRETTYINDENT_STD    8

#define PRETTYINDENT_JOIN   4

#define PRETTYINDENT_VAR    4

#define PRETTYINDENT_LIMIT    40  /* wrap limit */

/* Pretty flags */

#define PRETTYFLAG_PAREN    0x0001

#define PRETTYFLAG_INDENT   0x0002

#define PRETTYFLAG_SCHEMA   0x0004

/* Standard conversion of a "bool pretty" option to detailed flags */

#define GET_PRETTY_FLAGS(pretty) \

  ((pretty) ? (PRETTYFLAG_PAREN | PRETTYFLAG_INDENT | PRETTYFLAG_SCHEMA) \

   : PRETTYFLAG_INDENT)

/* Default line length for pretty-print wrapping: 0 means wrap always */

#define WRAP_COLUMN_DEFAULT   0

/* macros to test if pretty action needed */

#define PRETTY_PAREN(context) ((context)->prettyFlags & PRETTYFLAG_PAREN)

#define PRETTY_INDENT(context)  ((context)->prettyFlags & PRETTYFLAG_INDENT)

#define PRETTY_SCHEMA(context)  ((context)->prettyFlags & PRETTYFLAG_SCHEMA)

/* ----------

 * Local data types

 * ----------

 */

/* Context info needed for invoking a recursive querytree display routine */

typedef struct

{

  StringInfo  buf;      /* output buffer to append to */

  List     *namespaces;   /* List of deparse_namespace nodes */

  TupleDesc resultDesc;   /* if top level of a view, the view's tupdesc */

  List     *targetList;   /* Current query level's SELECT targetlist */

  List     *windowClause; /* Current query level's WINDOW clause */

  int     prettyFlags;  /* enabling of pretty-print functions */

  int     wrapColumn;   /* max line length, or -1 for no limit */

  int     indentLevel;  /* current indent level for pretty-print */

  bool    varprefix;    /* true to print prefixes on Vars */

  bool    colNamesVisible;  /* do we care about output column names? */

  bool    inGroupBy;    /* deparsing GROUP BY clause? */

  bool    varInOrderBy; /* deparsing simple Var in ORDER BY? */

  Bitmapset  *appendparents;  /* if not null, map child Vars of these relids

                 * back to the parent rel */

} deparse_context;

/*

 * Each level of query context around a subtree needs a level of Var namespace.

 * A Var having varlevelsup=N refers to the N'th item (counting from 0) in

 * the current context's namespaces list.

 *

 * rtable is the list of actual RTEs from the Query or PlannedStmt.

 * rtable_names holds the alias name to be used for each RTE (either a C

 * string, or NULL for nameless RTEs such as unnamed joins).

 * rtable_columns holds the column alias names to be used for each RTE.

 *

 * subplans is a list of Plan trees for SubPlans and CTEs (it's only used

 * in the PlannedStmt case).

 * ctes is a list of CommonTableExpr nodes (only used in the Query case).

 * appendrels, if not null (it's only used in the PlannedStmt case), is an

 * array of AppendRelInfo nodes, indexed by child relid.  We use that to map

 * child-table Vars to their inheritance parents.

 *

 * In some cases we need to make names of merged JOIN USING columns unique

 * across the whole query, not only per-RTE.  If so, unique_using is true

 * and using_names is a list of C strings representing names already assigned

 * to USING columns.

 *

 * When deparsing plan trees, there is always just a single item in the

 * deparse_namespace list (since a plan tree never contains Vars with

 * varlevelsup > 0).  We store the Plan node that is the immediate

 * parent of the expression to be deparsed, as well as a list of that

 * Plan's ancestors.  In addition, we store its outer and inner subplan nodes,

 * as well as their targetlists, and the index tlist if the current plan node

 * might contain INDEX_VAR Vars.  (These fields could be derived on-the-fly

 * from the current Plan node, but it seems notationally clearer to set them

 * up as separate fields.)

 */

typedef struct

{

  List     *rtable;     /* List of RangeTblEntry nodes */

  List     *rtable_names; /* Parallel list of names for RTEs */

  List     *rtable_columns; /* Parallel list of deparse_columns structs */

  List     *subplans;   /* List of Plan trees for SubPlans */

  List     *ctes;     /* List of CommonTableExpr nodes */

  AppendRelInfo **appendrels; /* Array of AppendRelInfo nodes, or NULL */

  char     *ret_old_alias;  /* alias for OLD in RETURNING list */

  char     *ret_new_alias;  /* alias for NEW in RETURNING list */

  /* Workspace for column alias assignment: */

  bool    unique_using; /* Are we making USING names globally unique */

  List     *using_names;  /* List of assigned names for USING columns */

  /* Remaining fields are used only when deparsing a Plan tree: */

  Plan     *plan;     /* immediate parent of current expression */

  List     *ancestors;    /* ancestors of plan */

  Plan     *outer_plan;   /* outer subnode, or NULL if none */

  Plan     *inner_plan;   /* inner subnode, or NULL if none */

  List     *outer_tlist;  /* referent for OUTER_VAR Vars */

  List     *inner_tlist;  /* referent for INNER_VAR Vars */

  List     *index_tlist;  /* referent for INDEX_VAR Vars */

  /* Special namespace representing a function signature: */

  char     *funcname;

  int     numargs;

  char    **argnames;

} deparse_namespace;

/*

 * Per-relation data about column alias names.

 *

 * Selecting aliases is unreasonably complicated because of the need to dump

 * rules/views whose underlying tables may have had columns added, deleted, or

 * renamed since the query was parsed.  We must nonetheless print the rule/view

 * in a form that can be reloaded and will produce the same results as before.

 *

 * For each RTE used in the query, we must assign column aliases that are

 * unique within that RTE.  SQL does not require this of the original query,

 * but due to factors such as *-expansion we need to be able to uniquely

 * reference every column in a decompiled query.  As long as we qualify all

 * column references, per-RTE uniqueness is sufficient for that.

 *

 * However, we can't ensure per-column name uniqueness for unnamed join RTEs,

 * since they just inherit column names from their input RTEs, and we can't

 * rename the columns at the join level.  Most of the time this isn't an issue

 * because we don't need to reference the join's output columns as such; we

 * can reference the input columns instead.  That approach can fail for merged

 * JOIN USING columns, however, so when we have one of those in an unnamed

 * join, we have to make that column's alias globally unique across the whole

 * query to ensure it can be referenced unambiguously.

 *

 * Another problem is that a JOIN USING clause requires the columns to be

 * merged to have the same aliases in both input RTEs, and that no other

 * columns in those RTEs or their children conflict with the USING names.

 * To handle that, we do USING-column alias assignment in a recursive

 * traversal of the query's jointree.  When descending through a JOIN with

 * USING, we preassign the USING column names to the child columns, overriding

 * other rules for column alias assignment.  We also mark each RTE with a list

 * of all USING column names selected for joins containing that RTE, so that

 * when we assign other columns' aliases later, we can avoid conflicts.

 *

 * Another problem is that if a JOIN's input tables have had columns added or

 * deleted since the query was parsed, we must generate a column alias list

 * for the join that matches the current set of input columns --- otherwise, a

 * change in the number of columns in the left input would throw off matching

 * of aliases to columns of the right input.  Thus, positions in the printable

 * column alias list are not necessarily one-for-one with varattnos of the

 * JOIN, so we need a separate new_colnames[] array for printing purposes.

 *

 * Finally, when dealing with wide tables we risk O(N^2) costs in assigning

 * non-duplicate column names.  We ameliorate that by using a hash table that

 * holds all the strings appearing in colnames, new_colnames, and parentUsing.

 */

typedef struct

{

  /*

   * colnames is an array containing column aliases to use for columns that

   * existed when the query was parsed.  Dropped columns have NULL entries.

   * This array can be directly indexed by varattno to get a Var's name.

   *

   * Non-NULL entries are guaranteed unique within the RTE, *except* when

   * this is for an unnamed JOIN RTE.  In that case we merely copy up names

   * from the two input RTEs.

   *

   * During the recursive descent in set_using_names(), forcible assignment

   * of a child RTE's column name is represented by pre-setting that element

   * of the child's colnames array.  So at that stage, NULL entries in this

   * array just mean that no name has been preassigned, not necessarily that

   * the column is dropped.

   */

  int     num_cols;   /* length of colnames[] array */

  char    **colnames;   /* array of C strings and NULLs */

  /*

   * new_colnames is an array containing column aliases to use for columns

   * that would exist if the query was re-parsed against the current

   * definitions of its base tables.  This is what to print as the column

   * alias list for the RTE.  This array does not include dropped columns,

   * but it will include columns added since original parsing.  Indexes in

   * it therefore have little to do with current varattno values.  As above,

   * entries are unique unless this is for an unnamed JOIN RTE.  (In such an

   * RTE, we never actually print this array, but we must compute it anyway

   * for possible use in computing column names of upper joins.) The

   * parallel array is_new_col marks which of these columns are new since

   * original parsing.  Entries with is_new_col false must match the

   * non-NULL colnames entries one-for-one.

   */

  int     num_new_cols; /* length of new_colnames[] array */

  char    **new_colnames; /* array of C strings */

  bool     *is_new_col;   /* array of bool flags */

  /* This flag tells whether we should actually print a column alias list */

  bool    printaliases;

  /* This list has all names used as USING names in joins above this RTE */

  List     *parentUsing;  /* names assigned to parent merged columns */

  /*

   * If this struct is for a JOIN RTE, we fill these fields during the

   * set_using_names() pass to describe its relationship to its child RTEs.

   *

   * leftattnos and rightattnos are arrays with one entry per existing

   * output column of the join (hence, indexable by join varattno).  For a

   * simple reference to a column of the left child, leftattnos[i] is the

   * child RTE's attno and rightattnos[i] is zero; and conversely for a

   * column of the right child.  But for merged columns produced by JOIN

   * USING/NATURAL JOIN, both leftattnos[i] and rightattnos[i] are nonzero.

   * Note that a simple reference might be to a child RTE column that's been

   * dropped; but that's OK since the column could not be used in the query.

   *

   * If it's a JOIN USING, usingNames holds the alias names selected for the

   * merged columns (these might be different from the original USING list,

   * if we had to modify names to achieve uniqueness).

   */

  int     leftrti;    /* rangetable index of left child */

  int     rightrti;   /* rangetable index of right child */

  int      *leftattnos;   /* left-child varattnos of join cols, or 0 */

  int      *rightattnos;  /* right-child varattnos of join cols, or 0 */

  List     *usingNames;   /* names assigned to merged columns */

  /*

   * Hash table holding copies of all the strings appearing in this struct's

   * colnames, new_colnames, and parentUsing.  We use a hash table only for

   * sufficiently wide relations, and only during the colname-assignment

   * functions set_relation_column_names and set_join_column_names;

   * otherwise, names_hash is NULL.

   */

  HTAB     *names_hash;   /* entries are just strings */

} deparse_columns;

/* This macro is analogous to rt_fetch(), but for deparse_columns structs */

#define deparse_columns_fetch(rangetable_index, dpns) \

  ((deparse_columns *) list_nth((dpns)->rtable_columns, (rangetable_index)-1))

/*

 * Entry in set_rtable_names' hash table

 */

typedef struct

{

  char    name[NAMEDATALEN];  /* Hash key --- must be first */

  int     counter;    /* Largest addition used so far for name */

} NameHashEntry;

/* Callback signature for resolve_special_varno() */

typedef void (*rsv_callback) (Node *node, deparse_context *context,

                void *callback_arg);

/* ----------

 * Global data

 * ----------

 */

static SPIPlanPtr plan_getrulebyoid = NULL;

static const char *const query_getrulebyoid = "SELECT * FROM pg_catalog.pg_rewrite WHERE oid = $1";

static SPIPlanPtr plan_getviewrule = NULL;

static const char *const query_getviewrule = "SELECT * FROM pg_catalog.pg_rewrite WHERE ev_class = $1 AND rulename = $2";

/* GUC parameters */

bool    quote_all_identifiers = false;

/* ----------

 * Local functions

 *

 * Most of these functions used to use fixed-size buffers to build their

 * results.  Now, they take an (already initialized) StringInfo object

 * as a parameter, and append their text output to its contents.

 * ----------

 */

static char *deparse_expression_pretty(Node *expr, List *dpcontext,

                     bool forceprefix, bool showimplicit,

                     int prettyFlags, int startIndent);

static char *pg_get_viewdef_worker(Oid viewoid,

                   int prettyFlags, int wrapColumn);

static char *pg_get_triggerdef_worker(Oid trigid, bool pretty);

static int  decompile_column_index_array(Datum column_index_array, Oid relId,

                     bool withPeriod, StringInfo buf);

static char *pg_get_ruledef_worker(Oid ruleoid, int prettyFlags);

static char *pg_get_indexdef_worker(Oid indexrelid, int colno,

                  const Oid *excludeOps,

                  bool attrsOnly, bool keysOnly,

                  bool showTblSpc, bool inherits,

                  int prettyFlags, bool missing_ok);

static char *pg_get_statisticsobj_worker(Oid statextid, bool columns_only,

                     bool missing_ok);

static char *pg_get_partkeydef_worker(Oid relid, int prettyFlags,

                    bool attrsOnly, bool missing_ok);

static char *pg_get_constraintdef_worker(Oid constraintId, bool fullCommand,

                     int prettyFlags, bool missing_ok);

static text *pg_get_expr_worker(text *expr, Oid relid, int prettyFlags);

static int  print_function_arguments(StringInfo buf, HeapTuple proctup,

                   bool print_table_args, bool print_defaults);

static void print_function_rettype(StringInfo buf, HeapTuple proctup);

static void print_function_trftypes(StringInfo buf, HeapTuple proctup);

static void print_function_sqlbody(StringInfo buf, HeapTuple proctup);

static void set_rtable_names(deparse_namespace *dpns, List *parent_namespaces,

               Bitmapset *rels_used);

static void set_deparse_for_query(deparse_namespace *dpns, Query *query,

                  List *parent_namespaces);

static void set_simple_column_names(deparse_namespace *dpns);

static bool has_dangerous_join_using(deparse_namespace *dpns, Node *jtnode);

static void set_using_names(deparse_namespace *dpns, Node *jtnode,

              List *parentUsing);

static void set_relation_column_names(deparse_namespace *dpns,

                    RangeTblEntry *rte,

                    deparse_columns *colinfo);

static void set_join_column_names(deparse_namespace *dpns, RangeTblEntry *rte,

                  deparse_columns *colinfo);

static bool colname_is_unique(const char *colname, deparse_namespace *dpns,

                deparse_columns *colinfo);

static char *make_colname_unique(char *colname, deparse_namespace *dpns,

                 deparse_columns *colinfo);

static void expand_colnames_array_to(deparse_columns *colinfo, int n);

static void build_colinfo_names_hash(deparse_columns *colinfo);

static void add_to_names_hash(deparse_columns *colinfo, const char *name);

static void destroy_colinfo_names_hash(deparse_columns *colinfo);

static void identify_join_columns(JoinExpr *j, RangeTblEntry *jrte,

                  deparse_columns *colinfo);

static char *get_rtable_name(int rtindex, deparse_context *context);

static void set_deparse_plan(deparse_namespace *dpns, Plan *plan);

static Plan *find_recursive_union(deparse_namespace *dpns,

                  WorkTableScan *wtscan);

static void push_child_plan(deparse_namespace *dpns, Plan *plan,

              deparse_namespace *save_dpns);

static void pop_child_plan(deparse_namespace *dpns,

               deparse_namespace *save_dpns);

static void push_ancestor_plan(deparse_namespace *dpns, ListCell *ancestor_cell,

                 deparse_namespace *save_dpns);

static void pop_ancestor_plan(deparse_namespace *dpns,

                deparse_namespace *save_dpns);

static void make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,

             int prettyFlags);

static void make_viewdef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,

             int prettyFlags, int wrapColumn);

static void get_query_def(Query *query, StringInfo buf, List *parentnamespace,

              TupleDesc resultDesc, bool colNamesVisible,

              int prettyFlags, int wrapColumn, int startIndent);

static void get_values_def(List *values_lists, deparse_context *context);

static void get_with_clause(Query *query, deparse_context *context);

static void get_select_query_def(Query *query, deparse_context *context);

static void get_insert_query_def(Query *query, deparse_context *context);

static void get_update_query_def(Query *query, deparse_context *context);

static void get_update_query_targetlist_def(Query *query, List *targetList,

                      deparse_context *context,

                      RangeTblEntry *rte);

static void get_delete_query_def(Query *query, deparse_context *context);

static void get_merge_query_def(Query *query, deparse_context *context);

static void get_utility_query_def(Query *query, deparse_context *context);

static char *get_lock_clause_strength(LockClauseStrength strength);

static void get_basic_select_query(Query *query, deparse_context *context);

static void get_target_list(List *targetList, deparse_context *context);

static void get_returning_clause(Query *query, deparse_context *context);

static void get_setop_query(Node *setOp, Query *query,

              deparse_context *context);

static Node *get_rule_sortgroupclause(Index ref, List *tlist,

                    bool force_colno,

                    deparse_context *context);

static void get_rule_groupingset(GroupingSet *gset, List *targetlist,

                 bool omit_parens, deparse_context *context);

static void get_rule_orderby(List *orderList, List *targetList,

               bool force_colno, deparse_context *context);

static void get_rule_windowclause(Query *query, deparse_context *context);

static void get_rule_windowspec(WindowClause *wc, List *targetList,

                deparse_context *context);

static void get_window_frame_options(int frameOptions,

                   Node *startOffset, Node *endOffset,

                   deparse_context *context);

static char *get_variable(Var *var, int levelsup, bool istoplevel,

              deparse_context *context);

static void get_special_variable(Node *node, deparse_context *context,

                 void *callback_arg);

static void resolve_special_varno(Node *node, deparse_context *context,

                  rsv_callback callback, void *callback_arg);

static Node *find_param_referent(Param *param, deparse_context *context,

                 deparse_namespace **dpns_p, ListCell **ancestor_cell_p);

static SubPlan *find_param_generator(Param *param, deparse_context *context,

                   int *column_p);

static SubPlan *find_param_generator_initplan(Param *param, Plan *plan,

                        int *column_p);

static void get_parameter(Param *param, deparse_context *context);

static const char *get_simple_binary_op_name(OpExpr *expr);

static bool isSimpleNode(Node *node, Node *parentNode, int prettyFlags);

static void appendContextKeyword(deparse_context *context, const char *str,

                 int indentBefore, int indentAfter, int indentPlus);

static void removeStringInfoSpaces(StringInfo str);

static void get_rule_expr(Node *node, deparse_context *context,

              bool showimplicit);

static void get_rule_expr_toplevel(Node *node, deparse_context *context,

                   bool showimplicit);

static void get_rule_list_toplevel(List *lst, deparse_context *context,

                   bool showimplicit);

static void get_rule_expr_funccall(Node *node, deparse_context *context,

                   bool showimplicit);

static bool looks_like_function(Node *node);

static void get_oper_expr(OpExpr *expr, deparse_context *context);

static void get_func_expr(FuncExpr *expr, deparse_context *context,

              bool showimplicit);

static void get_agg_expr(Aggref *aggref, deparse_context *context,

             Aggref *original_aggref);

static void get_agg_expr_helper(Aggref *aggref, deparse_context *context,

                Aggref *original_aggref, const char *funcname,

                const char *options, bool is_json_objectagg);

static void get_agg_combine_expr(Node *node, deparse_context *context,

                 void *callback_arg);

static void get_windowfunc_expr(WindowFunc *wfunc, deparse_context *context);

static void get_windowfunc_expr_helper(WindowFunc *wfunc, deparse_context *context,

                     const char *funcname, const char *options,

                     bool is_json_objectagg);

static bool get_func_sql_syntax(FuncExpr *expr, deparse_context *context);

static void get_coercion_expr(Node *arg, deparse_context *context,

                Oid resulttype, int32 resulttypmod,

                Node *parentNode);

static void get_const_expr(Const *constval, deparse_context *context,

               int showtype);

static void get_const_collation(Const *constval, deparse_context *context);

static void get_json_format(JsonFormat *format, StringInfo buf);

static void get_json_returning(JsonReturning *returning, StringInfo buf,

                 bool json_format_by_default);

static void get_json_constructor(JsonConstructorExpr *ctor,

                 deparse_context *context, bool showimplicit);

static void get_json_constructor_options(JsonConstructorExpr *ctor,

                     StringInfo buf);

static void get_json_agg_constructor(JsonConstructorExpr *ctor,

                   deparse_context *context,

                   const char *funcname,

                   bool is_json_objectagg);

static void get_json_agg_constructor_expr(Node *node, deparse_context *context,

                      void *callback_arg);

static void simple_quote_literal(StringInfo buf, const char *val);

static void get_sublink_expr(SubLink *sublink, deparse_context *context);

static void get_tablefunc(TableFunc *tf, deparse_context *context,

              bool showimplicit);

static void get_from_clause(Query *query, const char *prefix,

              deparse_context *context);

static void get_from_clause_item(Node *jtnode, Query *query,

                 deparse_context *context);

static void get_rte_alias(RangeTblEntry *rte, int varno, bool use_as,

              deparse_context *context);

static void get_column_alias_list(deparse_columns *colinfo,

                  deparse_context *context);

static void get_from_clause_coldeflist(RangeTblFunction *rtfunc,

                     deparse_columns *colinfo,

                     deparse_context *context);

static void get_tablesample_def(TableSampleClause *tablesample,

                deparse_context *context);

static void get_opclass_name(Oid opclass, Oid actual_datatype,

               StringInfo buf);

static Node *processIndirection(Node *node, deparse_context *context);

static void printSubscripts(SubscriptingRef *sbsref, deparse_context *context);

static char *get_relation_name(Oid relid);

static char *generate_relation_name(Oid relid, List *namespaces);

static char *generate_qualified_relation_name(Oid relid);

static char *generate_function_name(Oid funcid, int nargs,

                  List *argnames, Oid *argtypes,

                  bool has_variadic, bool *use_variadic_p,

                  bool inGroupBy);

static char *generate_operator_name(Oid operid, Oid arg1, Oid arg2);

static void add_cast_to(StringInfo buf, Oid typid);

static char *generate_qualified_type_name(Oid typid);

static text *string_to_text(char *str);

static char *flatten_reloptions(Oid relid);

void    get_reloptions(StringInfo buf, Datum reloptions);

static void get_json_path_spec(Node *path_spec, deparse_context *context,

                 bool showimplicit);

static void get_json_table_columns(TableFunc *tf, JsonTablePathScan *scan,

                   deparse_context *context,

                   bool showimplicit);

static void get_json_table_nested_columns(TableFunc *tf, JsonTablePlan *plan,

                      deparse_context *context,

                      bool showimplicit,

                      bool needcomma);

#define only_marker(rte)  ((rte)->inh ? "" : "ONLY ")

/* ----------

 * pg_get_ruledef   - Do it all and return a text

 *          that could be used as a statement

 *          to recreate the rule

 * ----------

 */

Datum

pg_get_ruledef(PG_FUNCTION_ARGS)

{

  Oid     ruleoid = PG_GETARG_OID(0);

  int     prettyFlags;

  char     *res;

  prettyFlags = PRETTYFLAG_INDENT;

  res = pg_get_ruledef_worker(ruleoid, prettyFlags);

  if (res == NULL)

    PG_RETURN_NULL();

  PG_RETURN_TEXT_P(string_to_text(res));

}

Datum

pg_get_ruledef_ext(PG_FUNCTION_ARGS)

{

  Oid     ruleoid = PG_GETARG_OID(0);

  bool    pretty = PG_GETARG_BOOL(1);

  int     prettyFlags;

  char     *res;

  prettyFlags = GET_PRETTY_FLAGS(pretty);

  res = pg_get_ruledef_worker(ruleoid, prettyFlags);

  if (res == NULL)

    PG_RETURN_NULL();

  PG_RETURN_TEXT_P(string_to_text(res));

}

static char *

pg_get_ruledef_worker(Oid ruleoid, int prettyFlags)

{

  Datum   args[1];

  char    nulls[1];

  int     spirc;

  HeapTuple ruletup;

  TupleDesc rulettc;

  StringInfoData buf;

  /*

   * Do this first so that string is alloc'd in outer context not SPI's.

   */

  initStringInfo(&buf);

  /*

   * Connect to SPI manager

   */

  SPI_connect();

  /*

   * On the first call prepare the plan to lookup pg_rewrite. We read

   * pg_rewrite over the SPI manager instead of using the syscache to be

   * checked for read access on pg_rewrite.

   */

  if (plan_getrulebyoid == NULL)

  {

    Oid     argtypes[1];

    SPIPlanPtr  plan;

    argtypes[0] = OIDOID;

    plan = SPI_prepare(query_getrulebyoid, 1, argtypes);

    if (plan == NULL)

      elog(ERROR, "SPI_prepare failed for \"%s\"", query_getrulebyoid);

    SPI_keepplan(plan);

    plan_getrulebyoid = plan;

  }

  /*

   * Get the pg_rewrite tuple for this rule

   */

  args[0] = ObjectIdGetDatum(ruleoid);

  nulls[0] = ' ';

  spirc = SPI_execute_plan(plan_getrulebyoid, args, nulls, true, 0);

  if (spirc != SPI_OK_SELECT)

    elog(ERROR, "failed to get pg_rewrite tuple for rule %u", ruleoid);

  if (SPI_processed != 1)

  {

    /*

     * There is no tuple data available here, just keep the output buffer

     * empty.

     */

  }

  else

  {

    /*

     * Get the rule's definition and put it into executor's memory

     */

    ruletup = SPI_tuptable->vals[0];

    rulettc = SPI_tuptable->tupdesc;

    make_ruledef(&buf, ruletup, rulettc, prettyFlags);

  }

  /*

   * Disconnect from SPI manager

   */

  if (SPI_finish() != SPI_OK_FINISH)

    elog(ERROR, "SPI_finish failed");

  if (buf.len == 0)

    return NULL;

  return buf.data;

}

/* ----------

 * pg_get_viewdef   - Mainly the same thing, but we

 *          only return the SELECT part of a view

 * ----------

 */

Datum

pg_get_viewdef(PG_FUNCTION_ARGS)

{

  /* By OID */

  Oid     viewoid = PG_GETARG_OID(0);

  int     prettyFlags;

  char     *res;

  prettyFlags = PRETTYFLAG_INDENT;

  res = pg_get_viewdef_worker(viewoid, prettyFlags, WRAP_COLUMN_DEFAULT);

  if (res == NULL)

    PG_RETURN_NULL();

  PG_RETURN_TEXT_P(string_to_text(res));

}

Datum

pg_get_viewdef_ext(PG_FUNCTION_ARGS)

{

  /* By OID */

  Oid     viewoid = PG_GETARG_OID(0);

  bool    pretty = PG_GETARG_BOOL(1);

  int     prettyFlags;

  char     *res;

  prettyFlags = GET_PRETTY_FLAGS(pretty);

  res = pg_get_viewdef_worker(viewoid, prettyFlags, WRAP_COLUMN_DEFAULT);

  if (res == NULL)

    PG_RETURN_NULL();

  PG_RETURN_TEXT_P(string_to_text(res));

}

Datum

pg_get_viewdef_wrap(PG_FUNCTION_ARGS)

{

  /* By OID */

  Oid     viewoid = PG_GETARG_OID(0);

  int     wrap = PG_GETARG_INT32(1);

  int     prettyFlags;

  char     *res;

  /* calling this implies we want pretty printing */

  prettyFlags = GET_PRETTY_FLAGS(true);

  res = pg_get_viewdef_worker(viewoid, prettyFlags, wrap);

  if (res == NULL)

    PG_RETURN_NULL();

  PG_RETURN_TEXT_P(string_to_text(res));

}

Datum

pg_get_viewdef_name(PG_FUNCTION_ARGS)

{

  /* By qualified name */

  text     *viewname = PG_GETARG_TEXT_PP(0);

  int     prettyFlags;

  RangeVar   *viewrel;

  Oid     viewoid;

  char     *res;

  prettyFlags = PRETTYFLAG_INDENT;

  /* Look up view name.  Can't lock it - we might not have privileges. */

  viewrel = makeRangeVarFromNameList(textToQualifiedNameList(viewname));

  viewoid = RangeVarGetRelid(viewrel, NoLock, false);

  res = pg_get_viewdef_worker(viewoid, prettyFlags, WRAP_COLUMN_DEFAULT);

  if (res == NULL)

    PG_RETURN_NULL();

  PG_RETURN_TEXT_P(string_to_text(res));

}

Datum

pg_get_viewdef_name_ext(PG_FUNCTION_ARGS)

{

  /* By qualified name */

  text     *viewname = PG_GETARG_TEXT_PP(0);

  bool    pretty = PG_GETARG_BOOL(1);

  int     prettyFlags;

  RangeVar   *viewrel;

  Oid     viewoid;

  char     *res;

  prettyFlags = GET_PRETTY_FLAGS(pretty);

  /* Look up view name.  Can't lock it - we might not have privileges. */

  viewrel = makeRangeVarFromNameList(textToQualifiedNameList(viewname));

  viewoid = RangeVarGetRelid(viewrel, NoLock, false);

  res = pg_get_viewdef_worker(viewoid, prettyFlags, WRAP_COLUMN_DEFAULT);

  if (res == NULL)

    PG_RETURN_NULL();

  PG_RETURN_TEXT_P(string_to_text(res));

}

/*

 * Common code for by-OID and by-name variants of pg_get_viewdef

 */

static char *

pg_get_viewdef_worker(Oid viewoid, int prettyFlags, int wrapColumn)

{

  Datum   args[2];

  char    nulls[2];

  int     spirc;

  HeapTuple ruletup;

  TupleDesc rulettc;

  StringInfoData buf;

  /*

   * Do this first so that string is alloc'd in outer context not SPI's.

   */

  initStringInfo(&buf);

  /*

   * Connect to SPI manager

   */

  SPI_connect();

  /*

   * On the first call prepare the plan to lookup pg_rewrite. We read

   * pg_rewrite over the SPI manager instead of using the syscache to be

   * checked for read access on pg_rewrite.

   */

  if (plan_getviewrule == NULL)

  {

    Oid     argtypes[2];

    SPIPlanPtr  plan;

    argtypes[0] = OIDOID;

    argtypes[1] = NAMEOID;

    plan = SPI_prepare(query_getviewrule, 2, argtypes);

    if (plan == NULL)

      elog(ERROR, "SPI_prepare failed for \"%s\"", query_getviewrule);

    SPI_keepplan(plan);

    plan_getviewrule = plan;

  }

  /*

   * Get the pg_rewrite tuple for the view's SELECT rule

   */

  args[0] = ObjectIdGetDatum(viewoid);

  args[1] = DirectFunctionCall1(namein, CStringGetDatum(ViewSelectRuleName));

  nulls[0] = ' ';

  nulls[1] = ' ';

  spirc = SPI_execute_plan(plan_getviewrule, args, nulls, true, 0);

  if (spirc != SPI_OK_SELECT)

    elog(ERROR, "failed to get pg_rewrite tuple for view %u", viewoid);

  if (SPI_processed != 1)

  {

    /*

     * There is no tuple data available here, just keep the output buffer

     * empty.

     */

  }

  else

  {

    /*

     * Get the rule's definition and put it into executor's memory

     */

    ruletup = SPI_tuptable->vals[0];

    rulettc = SPI_tuptable->tupdesc;

    make_viewdef(&buf, ruletup, rulettc, prettyFlags, wrapColumn);

  }

  /*

   * Disconnect from SPI manager

   */

  if (SPI_finish() != SPI_OK_FINISH)

    elog(ERROR, "SPI_finish failed");

  if (buf.len == 0)

    return NULL;

  return buf.data;

}

/* ----------

 * pg_get_triggerdef    - Get the definition of a trigger

 * ----------

 */

Datum

pg_get_triggerdef(PG_FUNCTION_ARGS)

{

  Oid     trigid = PG_GETARG_OID(0);

  char     *res;

  res = pg_get_triggerdef_worker(trigid, false);

  if (res == NULL)

    PG_RETURN_NULL();

  PG_RETURN_TEXT_P(string_to_text(res));

}

Datum

pg_get_triggerdef_ext(PG_FUNCTION_ARGS)

{

  Oid     trigid = PG_GETARG_OID(0);

  bool    pretty = PG_GETARG_BOOL(1);

  char     *res;

  res = pg_get_triggerdef_worker(trigid, pretty);

  if (res == NULL)

    PG_RETURN_NULL();

  PG_RETURN_TEXT_P(string_to_text(res));

}

static char *

pg_get_triggerdef_worker(Oid trigid, bool pretty)

{

  HeapTuple ht_trig;

  Form_pg_trigger trigrec;

  StringInfoData buf;

  Relation  tgrel;

  ScanKeyData skey[1];

  SysScanDesc tgscan;

  int     findx = 0;

  char     *tgname;

  char     *tgoldtable;

  char     *tgnewtable;

  Datum   value;

  bool    isnull;

  /*

   * Fetch the pg_trigger tuple by the Oid of the trigger

   */

  tgrel = table_open(TriggerRelationId, AccessShareLock);

  ScanKeyInit(&skey[0],

        Anum_pg_trigger_oid,

        BTEqualStrategyNumber, F_OIDEQ,

        ObjectIdGetDatum(trigid));

  tgscan = systable_beginscan(tgrel, TriggerOidIndexId, true,

                NULL, 1, skey);

  ht_trig = systable_getnext(tgscan);

  if (!HeapTupleIsValid(ht_trig))

  {

    systable_endscan(tgscan);

    table_close(tgrel, AccessShareLock);

    return NULL;

  }

  trigrec = (Form_pg_trigger) GETSTRUCT(ht_trig);

  /*

   * Start the trigger definition. Note that the trigger's name should never

   * be schema-qualified, but the trigger rel's name may be.

   */

  initStringInfo(&buf);

  tgname = NameStr(trigrec->tgname);

  appendStringInfo(&buf, "CREATE %sTRIGGER %s ",

           OidIsValid(trigrec->tgconstraint) ? "CONSTRAINT " : "",

           quote_identifier(tgname));

  if (TRIGGER_FOR_BEFORE(trigrec->tgtype))

    appendStringInfoString(&buf, "BEFORE");

  else if (TRIGGER_FOR_AFTER(trigrec->tgtype))

    appendStringInfoString(&buf, "AFTER");

  else if (TRIGGER_FOR_INSTEAD(trigrec->tgtype))

    appendStringInfoString(&buf, "INSTEAD OF");

  else

    elog(ERROR, "unexpected tgtype value: %d", trigrec->tgtype);

  if (TRIGGER_FOR_INSERT(trigrec->tgtype))

  {

    appendStringInfoString(&buf, " INSERT");

    findx++;

  }

  if (TRIGGER_FOR_DELETE(trigrec->tgtype))

  {

    if (findx > 0)

      appendStringInfoString(&buf, " OR DELETE");

    else

      appendStringInfoString(&buf, " DELETE");

    findx++;

  }

  if (TRIGGER_FOR_UPDATE(trigrec->tgtype))

  {

    if (findx > 0)

      appendStringInfoString(&buf, " OR UPDATE");

    else

      appendStringInfoString(&buf, " UPDATE");

    findx++;

    /* tgattr is first var-width field, so OK to access directly */

    if (trigrec->tgattr.dim1 > 0)

    {

      int     i;

      appendStringInfoString(&buf, " OF ");

      for (i = 0; i < trigrec->tgattr.dim1; i++)

      {

        char     *attname;

        if (i > 0)

          appendStringInfoString(&buf, ", ");

        attname = get_attname(trigrec->tgrelid,

                    trigrec->tgattr.values[i], false);

        appendStringInfoString(&buf, quote_identifier(attname));

      }

    }

  }

  if (TRIGGER_FOR_TRUNCATE(trigrec->tgtype))

  {

    if (findx > 0)

      appendStringInfoString(&buf, " OR TRUNCATE");

    else

      appendStringInfoString(&buf, " TRUNCATE");

    findx++;

  }

  /*