ruleutils.c File Reference

#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/sysattr.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_node.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"

Include dependency graph for ruleutils.c:

Go to the source code of this file.

Data Structures
struct	deparse_context
struct	deparse_namespace
struct	deparse_columns
struct	NameHashEntry

Macros
#define	PRETTYINDENT_STD   8
#define	PRETTYINDENT_JOIN   4
#define	PRETTYINDENT_VAR   4
#define	PRETTYINDENT_LIMIT   40 /* wrap limit */
#define	PRETTYFLAG_PAREN   0x0001
#define	PRETTYFLAG_INDENT   0x0002
#define	PRETTYFLAG_SCHEMA   0x0004
#define	GET_PRETTY_FLAGS(pretty)
#define	WRAP_COLUMN_DEFAULT   0
#define	PRETTY_PAREN(context)   ((context)->prettyFlags & PRETTYFLAG_PAREN)
#define	PRETTY_INDENT(context)   ((context)->prettyFlags & PRETTYFLAG_INDENT)
#define	PRETTY_SCHEMA(context)   ((context)->prettyFlags & PRETTYFLAG_SCHEMA)
#define	deparse_columns_fetch(rangetable_index, dpns)    ((deparse_columns *) list_nth((dpns)->rtable_columns, (rangetable_index)-1))
#define	only_marker(rte)   ((rte)->inh ? "" : "ONLY ")

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

Functions
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, 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, const char *relname, 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	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, TupleDesc resultDesc, bool colNamesVisible)
static void	get_insert_query_def (Query *query, deparse_context *context, bool colNamesVisible)
static void	get_update_query_def (Query *query, deparse_context *context, bool colNamesVisible)
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, bool colNamesVisible)
static void	get_merge_query_def (Query *query, deparse_context *context, bool colNamesVisible)
static void	get_utility_query_def (Query *query, deparse_context *context)
static void	get_basic_select_query (Query *query, deparse_context *context, TupleDesc resultDesc, bool colNamesVisible)
static void	get_target_list (List *targetList, deparse_context *context, TupleDesc resultDesc, bool colNamesVisible)
static void	get_setop_query (Node *setOp, Query *query, deparse_context *context, TupleDesc resultDesc, bool colNamesVisible)
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 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 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_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	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, ParseExprKind special_exprkind)
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)
static void	get_reloptions (StringInfo buf, Datum reloptions)
Datum	pg_get_ruledef (PG_FUNCTION_ARGS)
Datum	pg_get_ruledef_ext (PG_FUNCTION_ARGS)
Datum	pg_get_viewdef (PG_FUNCTION_ARGS)
Datum	pg_get_viewdef_ext (PG_FUNCTION_ARGS)
Datum	pg_get_viewdef_wrap (PG_FUNCTION_ARGS)
Datum	pg_get_viewdef_name (PG_FUNCTION_ARGS)
Datum	pg_get_viewdef_name_ext (PG_FUNCTION_ARGS)
Datum	pg_get_triggerdef (PG_FUNCTION_ARGS)
Datum	pg_get_triggerdef_ext (PG_FUNCTION_ARGS)
Datum	pg_get_indexdef (PG_FUNCTION_ARGS)
Datum	pg_get_indexdef_ext (PG_FUNCTION_ARGS)
char *	pg_get_indexdef_string (Oid indexrelid)
char *	pg_get_indexdef_columns (Oid indexrelid, bool pretty)
char *	pg_get_indexdef_columns_extended (Oid indexrelid, bits16 flags)
char *	pg_get_querydef (Query *query, bool pretty)
Datum	pg_get_statisticsobjdef (PG_FUNCTION_ARGS)
char *	pg_get_statisticsobjdef_string (Oid statextid)
Datum	pg_get_statisticsobjdef_columns (PG_FUNCTION_ARGS)
Datum	pg_get_statisticsobjdef_expressions (PG_FUNCTION_ARGS)
Datum	pg_get_partkeydef (PG_FUNCTION_ARGS)
char *	pg_get_partkeydef_columns (Oid relid, bool pretty)
Datum	pg_get_partition_constraintdef (PG_FUNCTION_ARGS)
char *	pg_get_partconstrdef_string (Oid partitionId, char *aliasname)
Datum	pg_get_constraintdef (PG_FUNCTION_ARGS)
Datum	pg_get_constraintdef_ext (PG_FUNCTION_ARGS)
char *	pg_get_constraintdef_command (Oid constraintId)
Datum	pg_get_expr (PG_FUNCTION_ARGS)
Datum	pg_get_expr_ext (PG_FUNCTION_ARGS)
Datum	pg_get_userbyid (PG_FUNCTION_ARGS)
Datum	pg_get_serial_sequence (PG_FUNCTION_ARGS)
Datum	pg_get_functiondef (PG_FUNCTION_ARGS)
Datum	pg_get_function_arguments (PG_FUNCTION_ARGS)
Datum	pg_get_function_identity_arguments (PG_FUNCTION_ARGS)
Datum	pg_get_function_result (PG_FUNCTION_ARGS)
static bool	is_input_argument (int nth, const char *argmodes)
Datum	pg_get_function_arg_default (PG_FUNCTION_ARGS)
Datum	pg_get_function_sqlbody (PG_FUNCTION_ARGS)
char *	deparse_expression (Node *expr, List *dpcontext, bool forceprefix, bool showimplicit)
List *	deparse_context_for (const char *aliasname, Oid relid)
List *	deparse_context_for_plan_tree (PlannedStmt *pstmt, List *rtable_names)
List *	set_deparse_context_plan (List *dpcontext, Plan *plan, List *ancestors)
List *	select_rtable_names_for_explain (List *rtable, Bitmapset *rels_used)
static RangeTblEntry *	get_simple_values_rte (Query *query, TupleDesc resultDesc)
static const char *	get_name_for_var_field (Var *var, int fieldno, int levelsup, deparse_context *context)
static void	get_rule_expr_paren (Node *node, deparse_context *context, bool showimplicit, Node *parentNode)
static void	get_json_returning (JsonReturning *returning, StringInfo buf, bool json_format_by_default)
char *	generate_opclass_name (Oid opclass)
const char *	quote_identifier (const char *ident)
char *	quote_qualified_identifier (const char *qualifier, const char *ident)
void	generate_operator_clause (StringInfo buf, const char *leftop, Oid leftoptype, Oid opoid, const char *rightop, Oid rightoptype)
char *	generate_collation_name (Oid collid)
char *	get_range_partbound_string (List *bound_datums)

Variables
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"
bool	quote_all_identifiers = false

Macro Definition Documentation

deparse_columns_fetch

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

Definition at line 297 of file ruleutils.c.

GET_PRETTY_FLAGS

#define GET_PRETTY_FLAGS

(

pretty

)

Value:

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

Definition at line 95 of file ruleutils.c.

only_marker

#define only_marker

(

rte

)

((rte)->inh ? "" : "ONLY ")

Definition at line 522 of file ruleutils.c.

PRETTY_INDENT

#define PRETTY_INDENT

(

context

)

((context)->prettyFlags & PRETTYFLAG_INDENT)

Definition at line 104 of file ruleutils.c.

PRETTY_PAREN

#define PRETTY_PAREN

(

context

)

((context)->prettyFlags & PRETTYFLAG_PAREN)

Definition at line 103 of file ruleutils.c.

PRETTY_SCHEMA

#define PRETTY_SCHEMA

(

context

)

((context)->prettyFlags & PRETTYFLAG_SCHEMA)

Definition at line 105 of file ruleutils.c.

PRETTYFLAG_INDENT

#define PRETTYFLAG_INDENT   0x0002

Definition at line 91 of file ruleutils.c.

PRETTYFLAG_PAREN

#define PRETTYFLAG_PAREN   0x0001

Definition at line 90 of file ruleutils.c.

PRETTYFLAG_SCHEMA

#define PRETTYFLAG_SCHEMA   0x0004

Definition at line 92 of file ruleutils.c.

PRETTYINDENT_JOIN

#define PRETTYINDENT_JOIN   4

Definition at line 84 of file ruleutils.c.

PRETTYINDENT_LIMIT

#define PRETTYINDENT_LIMIT   40 /* wrap limit */

Definition at line 87 of file ruleutils.c.

PRETTYINDENT_STD

#define PRETTYINDENT_STD   8

Definition at line 83 of file ruleutils.c.

PRETTYINDENT_VAR

#define PRETTYINDENT_VAR   4

Definition at line 85 of file ruleutils.c.

WRAP_COLUMN_DEFAULT

#define WRAP_COLUMN_DEFAULT   0

Definition at line 100 of file ruleutils.c.

Typedef Documentation

rsv_callback

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

Definition at line 310 of file ruleutils.c.

Function Documentation

add_cast_to()

static void add_cast_to ( StringInfo  buf, Oid  typid  )

static

Definition at line 12413 of file ruleutils.c.

{
    HeapTuple   typetup;
    Form_pg_type typform;
    char       *typname;
    char       *nspname;
 
    typetup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (!HeapTupleIsValid(typetup))
        elog(ERROR, "cache lookup failed for type %u", typid);
    typform = (Form_pg_type) GETSTRUCT(typetup);
 
    typname = NameStr(typform->typname);
    nspname = get_namespace_name_or_temp(typform->typnamespace);
 
    appendStringInfo(buf, "::%s.%s",
                     quote_identifier(nspname), quote_identifier(typname));
 
    ReleaseSysCache(typetup);
}

References appendStringInfo(), buf, elog(), ERROR, get_namespace_name_or_temp(), GETSTRUCT, HeapTupleIsValid, NameStr, ObjectIdGetDatum(), quote_identifier(), ReleaseSysCache(), SearchSysCache1(), TYPEOID, and typname.

Referenced by generate_operator_clause().

appendContextKeyword()

static void appendContextKeyword ( deparse_context *  context, const char *  str, int  indentBefore, int  indentAfter, int  indentPlus  )

static

Definition at line 8499 of file ruleutils.c.

{
    StringInfo  buf = context->buf;
 
    if (PRETTY_INDENT(context))
    {
        int         indentAmount;
 
        context->indentLevel += indentBefore;
 
        /* remove any trailing spaces currently in the buffer ... */
        removeStringInfoSpaces(buf);
        /* ... then add a newline and some spaces */
        appendStringInfoChar(buf, '\n');
 
        if (context->indentLevel < PRETTYINDENT_LIMIT)
            indentAmount = Max(context->indentLevel, 0) + indentPlus;
        else
        {
            /*
             * If we're indented more than PRETTYINDENT_LIMIT characters, try
             * to conserve horizontal space by reducing the per-level
             * indentation.  For best results the scale factor here should
             * divide all the indent amounts that get added to indentLevel
             * (PRETTYINDENT_STD, etc).  It's important that the indentation
             * not grow unboundedly, else deeply-nested trees use O(N^2)
             * whitespace; so we also wrap modulo PRETTYINDENT_LIMIT.
             */
            indentAmount = PRETTYINDENT_LIMIT +
                (context->indentLevel - PRETTYINDENT_LIMIT) /
                (PRETTYINDENT_STD / 2);
            indentAmount %= PRETTYINDENT_LIMIT;
            /* scale/wrap logic affects indentLevel, but not indentPlus */
            indentAmount += indentPlus;
        }
        appendStringInfoSpaces(buf, indentAmount);
 
        appendStringInfoString(buf, str);
 
        context->indentLevel += indentAfter;
        if (context->indentLevel < 0)
            context->indentLevel = 0;
    }
    else
        appendStringInfoString(buf, str);
}

References appendStringInfoChar(), appendStringInfoSpaces(), appendStringInfoString(), deparse_context::buf, buf, deparse_context::indentLevel, Max, PRETTY_INDENT, PRETTYINDENT_LIMIT, PRETTYINDENT_STD, removeStringInfoSpaces(), and generate_unaccent_rules::str.

Referenced by get_basic_select_query(), get_delete_query_def(), get_from_clause(), get_from_clause_item(), get_insert_query_def(), get_merge_query_def(), get_rule_expr(), get_rule_windowclause(), get_select_query_def(), get_setop_query(), get_target_list(), get_update_query_def(), get_utility_query_def(), and get_with_clause().

colname_is_unique()

static bool colname_is_unique ( const char *  colname, deparse_namespace *  dpns, deparse_columns *  colinfo  )

static

Definition at line 4764 of file ruleutils.c.

{
    int         i;
    ListCell   *lc;
 
    /* Check against already-assigned column aliases within RTE */
    for (i = 0; i < colinfo->num_cols; i++)
    {
        char       *oldname = colinfo->colnames[i];
 
        if (oldname && strcmp(oldname, colname) == 0)
            return false;
    }
 
    /*
     * If we're building a new_colnames array, check that too (this will be
     * partially but not completely redundant with the previous checks)
     */
    for (i = 0; i < colinfo->num_new_cols; i++)
    {
        char       *oldname = colinfo->new_colnames[i];
 
        if (oldname && strcmp(oldname, colname) == 0)
            return false;
    }
 
    /* Also check against USING-column names that must be globally unique */
    foreach(lc, dpns->using_names)
    {
        char       *oldname = (char *) lfirst(lc);
 
        if (strcmp(oldname, colname) == 0)
            return false;
    }
 
    /* Also check against names already assigned for parent-join USING cols */
    foreach(lc, colinfo->parentUsing)
    {
        char       *oldname = (char *) lfirst(lc);
 
        if (strcmp(oldname, colname) == 0)
            return false;
    }
 
    return true;
}

References deparse_columns::colnames, i, lfirst, deparse_columns::new_colnames, deparse_columns::num_cols, deparse_columns::num_new_cols, deparse_columns::parentUsing, and deparse_namespace::using_names.

Referenced by make_colname_unique().

decompile_column_index_array()

static int decompile_column_index_array ( Datum  column_index_array, Oid  relId, StringInfo  buf  )

static

Definition at line 2577 of file ruleutils.c.

{
    Datum      *keys;
    int         nKeys;
    int         j;
 
    /* Extract data from array of int16 */
    deconstruct_array_builtin(DatumGetArrayTypeP(column_index_array), INT2OID,
                              &keys, NULL, &nKeys);
 
    for (j = 0; j < nKeys; j++)
    {
        char       *colName;
 
        colName = get_attname(relId, DatumGetInt16(keys[j]), false);
 
        if (j == 0)
            appendStringInfoString(buf, quote_identifier(colName));
        else
            appendStringInfo(buf, ", %s", quote_identifier(colName));
    }
 
    return nKeys;
}

References appendStringInfo(), appendStringInfoString(), buf, DatumGetArrayTypeP, DatumGetInt16(), deconstruct_array_builtin(), get_attname(), j, and quote_identifier().

Referenced by pg_get_constraintdef_worker().

deparse_context_for()

List* deparse_context_for	(	const char *	aliasname,
		Oid	relid
	)

Definition at line 3660 of file ruleutils.c.

{
    deparse_namespace *dpns;
    RangeTblEntry *rte;
 
    dpns = (deparse_namespace *) palloc0(sizeof(deparse_namespace));
 
    /* Build a minimal RTE for the rel */
    rte = makeNode(RangeTblEntry);
    rte->rtekind = RTE_RELATION;
    rte->relid = relid;
    rte->relkind = RELKIND_RELATION;    /* no need for exactness here */
    rte->rellockmode = AccessShareLock;
    rte->alias = makeAlias(aliasname, NIL);
    rte->eref = rte->alias;
    rte->lateral = false;
    rte->inh = false;
    rte->inFromCl = true;
 
    /* Build one-element rtable */
    dpns->rtable = list_make1(rte);
    dpns->subplans = NIL;
    dpns->ctes = NIL;
    dpns->appendrels = NULL;
    set_rtable_names(dpns, NIL, NULL);
    set_simple_column_names(dpns);
 
    /* Return a one-deep namespace stack */
    return list_make1(dpns);
}

References AccessShareLock, RangeTblEntry::alias, deparse_namespace::appendrels, deparse_namespace::ctes, RangeTblEntry::eref, RangeTblEntry::inFromCl, RangeTblEntry::inh, RangeTblEntry::lateral, list_make1, makeAlias(), makeNode, NIL, palloc0(), RangeTblEntry::relid, RangeTblEntry::relkind, RangeTblEntry::rellockmode, deparse_namespace::rtable, RTE_RELATION, RangeTblEntry::rtekind, set_rtable_names(), set_simple_column_names(), and deparse_namespace::subplans.

Referenced by pg_get_constraintdef_worker(), pg_get_expr_worker(), pg_get_indexdef_worker(), pg_get_partconstrdef_string(), pg_get_partition_constraintdef(), pg_get_partkeydef_worker(), pg_get_statisticsobj_worker(), pg_get_statisticsobjdef_expressions(), transformPartitionBound(), and transformPartitionRangeBounds().

deparse_context_for_plan_tree()

List* deparse_context_for_plan_tree	(	PlannedStmt *	pstmt,
		List *	rtable_names
	)

Definition at line 3705 of file ruleutils.c.

{
    deparse_namespace *dpns;
 
    dpns = (deparse_namespace *) palloc0(sizeof(deparse_namespace));
 
    /* Initialize fields that stay the same across the whole plan tree */
    dpns->rtable = pstmt->rtable;
    dpns->rtable_names = rtable_names;
    dpns->subplans = pstmt->subplans;
    dpns->ctes = NIL;
    if (pstmt->appendRelations)
    {
        /* Set up the array, indexed by child relid */
        int         ntables = list_length(dpns->rtable);
        ListCell   *lc;
 
        dpns->appendrels = (AppendRelInfo **)
            palloc0((ntables + 1) * sizeof(AppendRelInfo *));
        foreach(lc, pstmt->appendRelations)
        {
            AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
            Index       crelid = appinfo->child_relid;
 
            Assert(crelid > 0 && crelid <= ntables);
            Assert(dpns->appendrels[crelid] == NULL);
            dpns->appendrels[crelid] = appinfo;
        }
    }
    else
        dpns->appendrels = NULL;    /* don't need it */
 
    /*
     * Set up column name aliases.  We will get rather bogus results for join
     * RTEs, but that doesn't matter because plan trees don't contain any join
     * alias Vars.
     */
    set_simple_column_names(dpns);
 
    /* Return a one-deep namespace stack */
    return list_make1(dpns);
}

References PlannedStmt::appendRelations, deparse_namespace::appendrels, Assert(), AppendRelInfo::child_relid, deparse_namespace::ctes, lfirst_node, list_length(), list_make1, NIL, palloc0(), deparse_namespace::rtable, PlannedStmt::rtable, deparse_namespace::rtable_names, set_simple_column_names(), deparse_namespace::subplans, and PlannedStmt::subplans.

Referenced by ExplainPrintPlan().

deparse_expression()

char* deparse_expression	(	Node *	expr,
		List *	dpcontext,
		bool	forceprefix,
		bool	showimplicit
	)

Definition at line 3600 of file ruleutils.c.

{
    return deparse_expression_pretty(expr, dpcontext, forceprefix,
                                     showimplicit, 0, 0);
}

References deparse_expression_pretty().

Referenced by AlterDomainDefault(), DefineDomain(), pg_get_function_arg_default(), pg_get_partconstrdef_string(), print_function_arguments(), show_expression(), show_grouping_set_keys(), show_memoize_info(), show_plan_tlist(), show_sort_group_keys(), show_tablesample(), transformPartitionBound(), and transformPartitionRangeBounds().

deparse_expression_pretty()

static char * deparse_expression_pretty ( Node *  expr, List *  dpcontext, bool  forceprefix, bool  showimplicit, int  prettyFlags, int  startIndent  )

static

Definition at line 3627 of file ruleutils.c.

{
    StringInfoData buf;
    deparse_context context;
 
    initStringInfo(&buf);
    context.buf = &buf;
    context.namespaces = dpcontext;
    context.windowClause = NIL;
    context.windowTList = NIL;
    context.varprefix = forceprefix;
    context.prettyFlags = prettyFlags;
    context.wrapColumn = WRAP_COLUMN_DEFAULT;
    context.indentLevel = startIndent;
    context.special_exprkind = EXPR_KIND_NONE;
    context.appendparents = NULL;
 
    get_rule_expr(expr, &context, showimplicit);
 
    return buf.data;
}

References deparse_context::appendparents, deparse_context::buf, buf, EXPR_KIND_NONE, get_rule_expr(), deparse_context::indentLevel, initStringInfo(), deparse_context::namespaces, NIL, deparse_context::prettyFlags, deparse_context::special_exprkind, deparse_context::varprefix, deparse_context::windowClause, deparse_context::windowTList, WRAP_COLUMN_DEFAULT, and deparse_context::wrapColumn.

Referenced by deparse_expression(), pg_get_constraintdef_worker(), pg_get_expr_worker(), pg_get_indexdef_worker(), pg_get_partition_constraintdef(), pg_get_partkeydef_worker(), pg_get_statisticsobj_worker(), and pg_get_statisticsobjdef_expressions().

expand_colnames_array_to()

static void expand_colnames_array_to ( deparse_columns *  colinfo, int  n  )

static

Definition at line 4857 of file ruleutils.c.

{
    if (n > colinfo->num_cols)
    {
        if (colinfo->colnames == NULL)
            colinfo->colnames = palloc0_array(char *, n);
        else
            colinfo->colnames = repalloc0_array(colinfo->colnames, char *, colinfo->num_cols, n);
        colinfo->num_cols = n;
    }
}

References deparse_columns::colnames, deparse_columns::num_cols, palloc0_array, and repalloc0_array.

Referenced by set_join_column_names(), set_relation_column_names(), and set_using_names().

find_param_referent()

static Node * find_param_referent ( Param *  param, deparse_context *  context, deparse_namespace **  dpns_p, ListCell **  ancestor_cell_p  )

static

Definition at line 8024 of file ruleutils.c.

{
    /* Initialize output parameters to prevent compiler warnings */
    *dpns_p = NULL;
    *ancestor_cell_p = NULL;
 
    /*
     * If it's a PARAM_EXEC parameter, look for a matching NestLoopParam or
     * SubPlan argument.  This will necessarily be in some ancestor of the
     * current expression's Plan node.
     */
    if (param->paramkind == PARAM_EXEC)
    {
        deparse_namespace *dpns;
        Plan       *child_plan;
        ListCell   *lc;
 
        dpns = (deparse_namespace *) linitial(context->namespaces);
        child_plan = dpns->plan;
 
        foreach(lc, dpns->ancestors)
        {
            Node       *ancestor = (Node *) lfirst(lc);
            ListCell   *lc2;
 
            /*
             * NestLoops transmit params to their inner child only.
             */
            if (IsA(ancestor, NestLoop) &&
                child_plan == innerPlan(ancestor))
            {
                NestLoop   *nl = (NestLoop *) ancestor;
 
                foreach(lc2, nl->nestParams)
                {
                    NestLoopParam *nlp = (NestLoopParam *) lfirst(lc2);
 
                    if (nlp->paramno == param->paramid)
                    {
                        /* Found a match, so return it */
                        *dpns_p = dpns;
                        *ancestor_cell_p = lc;
                        return (Node *) nlp->paramval;
                    }
                }
            }
 
            /*
             * If ancestor is a SubPlan, check the arguments it provides.
             */
            if (IsA(ancestor, SubPlan))
            {
                SubPlan    *subplan = (SubPlan *) ancestor;
                ListCell   *lc3;
                ListCell   *lc4;
 
                forboth(lc3, subplan->parParam, lc4, subplan->args)
                {
                    int         paramid = lfirst_int(lc3);
                    Node       *arg = (Node *) lfirst(lc4);
 
                    if (paramid == param->paramid)
                    {
                        /*
                         * Found a match, so return it.  But, since Vars in
                         * the arg are to be evaluated in the surrounding
                         * context, we have to point to the next ancestor item
                         * that is *not* a SubPlan.
                         */
                        ListCell   *rest;
 
                        for_each_cell(rest, dpns->ancestors,
                                      lnext(dpns->ancestors, lc))
                        {
                            Node       *ancestor2 = (Node *) lfirst(rest);
 
                            if (!IsA(ancestor2, SubPlan))
                            {
                                *dpns_p = dpns;
                                *ancestor_cell_p = rest;
                                return arg;
                            }
                        }
                        elog(ERROR, "SubPlan cannot be outermost ancestor");
                    }
                }
 
                /* SubPlan isn't a kind of Plan, so skip the rest */
                continue;
            }
 
            /*
             * We need not consider the ancestor's initPlan list, since
             * initplans never have any parParams.
             */
 
            /* No luck, crawl up to next ancestor */
            child_plan = (Plan *) ancestor;
        }
    }
 
    /* No referent found */
    return NULL;
}

References deparse_namespace::ancestors, arg, SubPlan::args, elog(), ERROR, for_each_cell, forboth, innerPlan, IsA, lfirst, lfirst_int, linitial, lnext(), deparse_context::namespaces, NestLoop::nestParams, PARAM_EXEC, Param::paramid, Param::paramkind, NestLoopParam::paramno, NestLoopParam::paramval, SubPlan::parParam, and deparse_namespace::plan.

Referenced by get_name_for_var_field(), and get_parameter().

find_recursive_union()

static Plan * find_recursive_union ( deparse_namespace *  dpns, WorkTableScan *  wtscan  )

static

Definition at line 5041 of file ruleutils.c.

{
    ListCell   *lc;
 
    foreach(lc, dpns->ancestors)
    {
        Plan       *ancestor = (Plan *) lfirst(lc);
 
        if (IsA(ancestor, RecursiveUnion) &&
            ((RecursiveUnion *) ancestor)->wtParam == wtscan->wtParam)
            return ancestor;
    }
    elog(ERROR, "could not find RecursiveUnion for WorkTableScan with wtParam %d",
         wtscan->wtParam);
    return NULL;
}

References deparse_namespace::ancestors, elog(), ERROR, IsA, lfirst, and WorkTableScan::wtParam.

Referenced by set_deparse_plan().

flatten_reloptions()

static char * flatten_reloptions ( Oid  relid )

static

Definition at line 12577 of file ruleutils.c.

{
    char       *result = NULL;
    HeapTuple   tuple;
    Datum       reloptions;
    bool        isnull;
 
    tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for relation %u", relid);
 
    reloptions = SysCacheGetAttr(RELOID, tuple,
                                 Anum_pg_class_reloptions, &isnull);
    if (!isnull)
    {
        StringInfoData buf;
 
        initStringInfo(&buf);
        get_reloptions(&buf, reloptions);
 
        result = buf.data;
    }
 
    ReleaseSysCache(tuple);
 
    return result;
}

References buf, elog(), ERROR, get_reloptions(), HeapTupleIsValid, initStringInfo(), ObjectIdGetDatum(), ReleaseSysCache(), RELOID, SearchSysCache1(), and SysCacheGetAttr().

Referenced by pg_get_constraintdef_worker(), and pg_get_indexdef_worker().

generate_collation_name()

char* generate_collation_name

(

Oid

collid

)

Definition at line 12477 of file ruleutils.c.

{
    HeapTuple   tp;
    Form_pg_collation colltup;
    char       *collname;
    char       *nspname;
    char       *result;
 
    tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(collid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for collation %u", collid);
    colltup = (Form_pg_collation) GETSTRUCT(tp);
    collname = NameStr(colltup->collname);
 
    if (!CollationIsVisible(collid))
        nspname = get_namespace_name_or_temp(colltup->collnamespace);
    else
        nspname = NULL;
 
    result = quote_qualified_identifier(nspname, collname);
 
    ReleaseSysCache(tp);
 
    return result;
}

References CollationIsVisible(), collid, COLLOID, elog(), ERROR, get_namespace_name_or_temp(), GETSTRUCT, HeapTupleIsValid, NameStr, ObjectIdGetDatum(), quote_qualified_identifier(), ReleaseSysCache(), and SearchSysCache1().

Referenced by get_const_collation(), get_from_clause_coldeflist(), get_rule_expr(), pg_collation_for(), pg_get_indexdef_worker(), and pg_get_partkeydef_worker().

generate_function_name()

static char * generate_function_name ( Oid  funcid, int  nargs, List *  argnames, Oid *  argtypes, bool  has_variadic, bool *  use_variadic_p, ParseExprKind  special_exprkind  )

static

Definition at line 12191 of file ruleutils.c.

{
    char       *result;
    HeapTuple   proctup;
    Form_pg_proc procform;
    char       *proname;
    bool        use_variadic;
    char       *nspname;
    FuncDetailCode p_result;
    Oid         p_funcid;
    Oid         p_rettype;
    bool        p_retset;
    int         p_nvargs;
    Oid         p_vatype;
    Oid        *p_true_typeids;
    bool        force_qualify = false;
 
    proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    if (!HeapTupleIsValid(proctup))
        elog(ERROR, "cache lookup failed for function %u", funcid);
    procform = (Form_pg_proc) GETSTRUCT(proctup);
    proname = NameStr(procform->proname);
 
    /*
     * Due to parser hacks to avoid needing to reserve CUBE, we need to force
     * qualification in some special cases.
     */
    if (special_exprkind == EXPR_KIND_GROUP_BY)
    {
        if (strcmp(proname, "cube") == 0 || strcmp(proname, "rollup") == 0)
            force_qualify = true;
    }
 
    /*
     * Determine whether VARIADIC should be printed.  We must do this first
     * since it affects the lookup rules in func_get_detail().
     *
     * We always print VARIADIC if the function has a merged variadic-array
     * argument.  Note that this is always the case for functions taking a
     * VARIADIC argument type other than VARIADIC ANY.  If we omitted VARIADIC
     * and printed the array elements as separate arguments, the call could
     * match a newer non-VARIADIC function.
     */
    if (use_variadic_p)
    {
        /* Parser should not have set funcvariadic unless fn is variadic */
        Assert(!has_variadic || OidIsValid(procform->provariadic));
        use_variadic = has_variadic;
        *use_variadic_p = use_variadic;
    }
    else
    {
        Assert(!has_variadic);
        use_variadic = false;
    }
 
    /*
     * The idea here is to schema-qualify only if the parser would fail to
     * resolve the correct function given the unqualified func name with the
     * specified argtypes and VARIADIC flag.  But if we already decided to
     * force qualification, then we can skip the lookup and pretend we didn't
     * find it.
     */
    if (!force_qualify)
        p_result = func_get_detail(list_make1(makeString(proname)),
                                   NIL, argnames, nargs, argtypes,
                                   !use_variadic, true, false,
                                   &p_funcid, &p_rettype,
                                   &p_retset, &p_nvargs, &p_vatype,
                                   &p_true_typeids, NULL);
    else
    {
        p_result = FUNCDETAIL_NOTFOUND;
        p_funcid = InvalidOid;
    }
 
    if ((p_result == FUNCDETAIL_NORMAL ||
         p_result == FUNCDETAIL_AGGREGATE ||
         p_result == FUNCDETAIL_WINDOWFUNC) &&
        p_funcid == funcid)
        nspname = NULL;
    else
        nspname = get_namespace_name_or_temp(procform->pronamespace);
 
    result = quote_qualified_identifier(nspname, proname);
 
    ReleaseSysCache(proctup);
 
    return result;
}

References Assert(), elog(), ERROR, EXPR_KIND_GROUP_BY, func_get_detail(), FUNCDETAIL_AGGREGATE, FUNCDETAIL_NORMAL, FUNCDETAIL_NOTFOUND, FUNCDETAIL_WINDOWFUNC, get_namespace_name_or_temp(), GETSTRUCT, HeapTupleIsValid, InvalidOid, list_make1, makeString(), NameStr, NIL, ObjectIdGetDatum(), OidIsValid, PROCOID, proname, quote_qualified_identifier(), ReleaseSysCache(), and SearchSysCache1().

Referenced by get_agg_expr_helper(), get_func_expr(), get_tablesample_def(), get_windowfunc_expr_helper(), pg_get_functiondef(), and pg_get_triggerdef_worker().

generate_opclass_name()

char* generate_opclass_name

(

Oid

opclass

)

Definition at line 11835 of file ruleutils.c.

{
    StringInfoData buf;
 
    initStringInfo(&buf);
    get_opclass_name(opclass, InvalidOid, &buf);
 
    return &buf.data[1];        /* get_opclass_name() prepends space */
}

References buf, get_opclass_name(), initStringInfo(), and InvalidOid.

Referenced by index_opclass_options().

generate_operator_clause()

void generate_operator_clause	(	StringInfo	buf,
		const char *	leftop,
		Oid	leftoptype,
		Oid	opoid,
		const char *	rightop,
		Oid	rightoptype
	)

Definition at line 12373 of file ruleutils.c.

{
    HeapTuple   opertup;
    Form_pg_operator operform;
    char       *oprname;
    char       *nspname;
 
    opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(opoid));
    if (!HeapTupleIsValid(opertup))
        elog(ERROR, "cache lookup failed for operator %u", opoid);
    operform = (Form_pg_operator) GETSTRUCT(opertup);
    Assert(operform->oprkind == 'b');
    oprname = NameStr(operform->oprname);
 
    nspname = get_namespace_name(operform->oprnamespace);
 
    appendStringInfoString(buf, leftop);
    if (leftoptype != operform->oprleft)
        add_cast_to(buf, operform->oprleft);
    appendStringInfo(buf, " OPERATOR(%s.", quote_identifier(nspname));
    appendStringInfoString(buf, oprname);
    appendStringInfo(buf, ") %s", rightop);
    if (rightoptype != operform->oprright)
        add_cast_to(buf, operform->oprright);
 
    ReleaseSysCache(opertup);
}

References add_cast_to(), appendStringInfo(), appendStringInfoString(), Assert(), buf, elog(), ERROR, get_namespace_name(), GETSTRUCT, HeapTupleIsValid, NameStr, ObjectIdGetDatum(), OPEROID, quote_identifier(), ReleaseSysCache(), and SearchSysCache1().

Referenced by refresh_by_match_merge(), and ri_GenerateQual().

generate_operator_name()

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

static

Definition at line 12296 of file ruleutils.c.

{
    StringInfoData buf;
    HeapTuple   opertup;
    Form_pg_operator operform;
    char       *oprname;
    char       *nspname;
    Operator    p_result;
 
    initStringInfo(&buf);
 
    opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operid));
    if (!HeapTupleIsValid(opertup))
        elog(ERROR, "cache lookup failed for operator %u", operid);
    operform = (Form_pg_operator) GETSTRUCT(opertup);
    oprname = NameStr(operform->oprname);
 
    /*
     * The idea here is to schema-qualify only if the parser would fail to
     * resolve the correct operator given the unqualified op name with the
     * specified argtypes.
     */
    switch (operform->oprkind)
    {
        case 'b':
            p_result = oper(NULL, list_make1(makeString(oprname)), arg1, arg2,
                            true, -1);
            break;
        case 'l':
            p_result = left_oper(NULL, list_make1(makeString(oprname)), arg2,
                                 true, -1);
            break;
        default:
            elog(ERROR, "unrecognized oprkind: %d", operform->oprkind);
            p_result = NULL;    /* keep compiler quiet */
            break;
    }
 
    if (p_result != NULL && oprid(p_result) == operid)
        nspname = NULL;
    else
    {
        nspname = get_namespace_name_or_temp(operform->oprnamespace);
        appendStringInfo(&buf, "OPERATOR(%s.", quote_identifier(nspname));
    }
 
    appendStringInfoString(&buf, oprname);
 
    if (nspname)
        appendStringInfoChar(&buf, ')');
 
    if (p_result != NULL)
        ReleaseSysCache(p_result);
 
    ReleaseSysCache(opertup);
 
    return buf.data;
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), buf, elog(), ERROR, get_namespace_name_or_temp(), GETSTRUCT, HeapTupleIsValid, initStringInfo(), left_oper(), list_make1, makeString(), NameStr, ObjectIdGetDatum(), oper(), OPEROID, oprid(), quote_identifier(), ReleaseSysCache(), and SearchSysCache1().

Referenced by get_oper_expr(), get_rule_expr(), get_rule_orderby(), get_simple_binary_op_name(), get_sublink_expr(), and pg_get_indexdef_worker().

generate_qualified_relation_name()

static char * generate_qualified_relation_name ( Oid  relid )

static

Definition at line 12149 of file ruleutils.c.

{
    HeapTuple   tp;
    Form_pg_class reltup;
    char       *relname;
    char       *nspname;
    char       *result;
 
    tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for relation %u", relid);
    reltup = (Form_pg_class) GETSTRUCT(tp);
    relname = NameStr(reltup->relname);
 
    nspname = get_namespace_name_or_temp(reltup->relnamespace);
    if (!nspname)
        elog(ERROR, "cache lookup failed for namespace %u",
             reltup->relnamespace);
 
    result = quote_qualified_identifier(nspname, relname);
 
    ReleaseSysCache(tp);
 
    return result;
}

References elog(), ERROR, get_namespace_name_or_temp(), GETSTRUCT, HeapTupleIsValid, NameStr, ObjectIdGetDatum(), quote_qualified_identifier(), ReleaseSysCache(), relname, RELOID, and SearchSysCache1().

Referenced by make_ruledef(), pg_get_constraintdef_worker(), pg_get_indexdef_worker(), pg_get_serial_sequence(), and pg_get_triggerdef_worker().

generate_qualified_type_name()

static char * generate_qualified_type_name ( Oid  typid )

static

Definition at line 12444 of file ruleutils.c.

{
    HeapTuple   tp;
    Form_pg_type typtup;
    char       *typname;
    char       *nspname;
    char       *result;
 
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for type %u", typid);
    typtup = (Form_pg_type) GETSTRUCT(tp);
    typname = NameStr(typtup->typname);
 
    nspname = get_namespace_name_or_temp(typtup->typnamespace);
    if (!nspname)
        elog(ERROR, "cache lookup failed for namespace %u",
             typtup->typnamespace);
 
    result = quote_qualified_identifier(nspname, typname);
 
    ReleaseSysCache(tp);
 
    return result;
}

References elog(), ERROR, get_namespace_name_or_temp(), GETSTRUCT, HeapTupleIsValid, NameStr, ObjectIdGetDatum(), quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), TYPEOID, and typname.

Referenced by pg_get_constraintdef_worker().

generate_relation_name()

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

static

Definition at line 12089 of file ruleutils.c.

{
    HeapTuple   tp;
    Form_pg_class reltup;
    bool        need_qual;
    ListCell   *nslist;
    char       *relname;
    char       *nspname;
    char       *result;
 
    tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for relation %u", relid);
    reltup = (Form_pg_class) GETSTRUCT(tp);
    relname = NameStr(reltup->relname);
 
    /* Check for conflicting CTE name */
    need_qual = false;
    foreach(nslist, namespaces)
    {
        deparse_namespace *dpns = (deparse_namespace *) lfirst(nslist);
        ListCell   *ctlist;
 
        foreach(ctlist, dpns->ctes)
        {
            CommonTableExpr *cte = (CommonTableExpr *) lfirst(ctlist);
 
            if (strcmp(cte->ctename, relname) == 0)
            {
                need_qual = true;
                break;
            }
        }
        if (need_qual)
            break;
    }
 
    /* Otherwise, qualify the name if not visible in search path */
    if (!need_qual)
        need_qual = !RelationIsVisible(relid);
 
    if (need_qual)
        nspname = get_namespace_name_or_temp(reltup->relnamespace);
    else
        nspname = NULL;
 
    result = quote_qualified_identifier(nspname, relname);
 
    ReleaseSysCache(tp);
 
    return result;
}

References CommonTableExpr::ctename, deparse_namespace::ctes, elog(), ERROR, get_namespace_name_or_temp(), GETSTRUCT, HeapTupleIsValid, lfirst, NameStr, ObjectIdGetDatum(), quote_qualified_identifier(), RelationIsVisible(), ReleaseSysCache(), relname, RELOID, and SearchSysCache1().

Referenced by get_delete_query_def(), get_from_clause_item(), get_insert_query_def(), get_merge_query_def(), get_rule_expr(), get_update_query_def(), make_ruledef(), pg_get_constraintdef_worker(), pg_get_indexdef_worker(), pg_get_statisticsobj_worker(), and pg_get_triggerdef_worker().

get_agg_combine_expr()

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

static

Definition at line 10207 of file ruleutils.c.

{
    Aggref     *aggref;
    Aggref     *original_aggref = callback_arg;
 
    if (!IsA(node, Aggref))
        elog(ERROR, "combining Aggref does not point to an Aggref");
 
    aggref = (Aggref *) node;
    get_agg_expr(aggref, context, original_aggref);
}

References elog(), ERROR, get_agg_expr(), and IsA.

Referenced by get_agg_expr_helper().

get_agg_expr()

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

static

Definition at line 10069 of file ruleutils.c.

{
    get_agg_expr_helper(aggref, context, original_aggref, NULL, NULL,
                        false);
}

References get_agg_expr_helper().

Referenced by get_agg_combine_expr(), and get_rule_expr().

get_agg_expr_helper()

static void get_agg_expr_helper ( Aggref *  aggref, deparse_context *  context, Aggref *  original_aggref, const char *  funcname, const char *  options, bool  is_json_objectagg  )

static

Definition at line 10081 of file ruleutils.c.

{
    StringInfo  buf = context->buf;
    Oid         argtypes[FUNC_MAX_ARGS];
    int         nargs;
    bool        use_variadic = false;
 
    /*
     * For a combining aggregate, we look up and deparse the corresponding
     * partial aggregate instead.  This is necessary because our input
     * argument list has been replaced; the new argument list always has just
     * one element, which will point to a partial Aggref that supplies us with
     * transition states to combine.
     */
    if (DO_AGGSPLIT_COMBINE(aggref->aggsplit))
    {
        TargetEntry *tle;
 
        Assert(list_length(aggref->args) == 1);
        tle = linitial_node(TargetEntry, aggref->args);
        resolve_special_varno((Node *) tle->expr, context,
                              get_agg_combine_expr, original_aggref);
        return;
    }
 
    /*
     * Mark as PARTIAL, if appropriate.  We look to the original aggref so as
     * to avoid printing this when recursing from the code just above.
     */
    if (DO_AGGSPLIT_SKIPFINAL(original_aggref->aggsplit))
        appendStringInfoString(buf, "PARTIAL ");
 
    /* Extract the argument types as seen by the parser */
    nargs = get_aggregate_argtypes(aggref, argtypes);
 
    if (!funcname)
        funcname = generate_function_name(aggref->aggfnoid, nargs, NIL,
                                          argtypes, aggref->aggvariadic,
                                          &use_variadic,
                                          context->special_exprkind);
 
    /* Print the aggregate name, schema-qualified if needed */
    appendStringInfo(buf, "%s(%s", funcname,
                     (aggref->aggdistinct != NIL) ? "DISTINCT " : "");
 
    if (AGGKIND_IS_ORDERED_SET(aggref->aggkind))
    {
        /*
         * Ordered-set aggregates do not use "*" syntax.  Also, we needn't
         * worry about inserting VARIADIC.  So we can just dump the direct
         * args as-is.
         */
        Assert(!aggref->aggvariadic);
        get_rule_expr((Node *) aggref->aggdirectargs, context, true);
        Assert(aggref->aggorder != NIL);
        appendStringInfoString(buf, ") WITHIN GROUP (ORDER BY ");
        get_rule_orderby(aggref->aggorder, aggref->args, false, context);
    }
    else
    {
        /* aggstar can be set only in zero-argument aggregates */
        if (aggref->aggstar)
            appendStringInfoChar(buf, '*');
        else
        {
            ListCell   *l;
            int         i;
 
            i = 0;
            foreach(l, aggref->args)
            {
                TargetEntry *tle = (TargetEntry *) lfirst(l);
                Node       *arg = (Node *) tle->expr;
 
                Assert(!IsA(arg, NamedArgExpr));
                if (tle->resjunk)
                    continue;
                if (i++ > 0)
                {
                    if (is_json_objectagg)
                    {
                        /*
                         * the ABSENT ON NULL and WITH UNIQUE args are printed
                         * separately, so ignore them here
                         */
                        if (i > 2)
                            break;
 
                        appendStringInfoString(buf, " : ");
                    }
                    else
                        appendStringInfoString(buf, ", ");
                }
                if (use_variadic && i == nargs)
                    appendStringInfoString(buf, "VARIADIC ");
                get_rule_expr(arg, context, true);
            }
        }
 
        if (aggref->aggorder != NIL)
        {
            appendStringInfoString(buf, " ORDER BY ");
            get_rule_orderby(aggref->aggorder, aggref->args, false, context);
        }
    }
 
    if (options)
        appendStringInfoString(buf, options);
 
    if (aggref->aggfilter != NULL)
    {
        appendStringInfoString(buf, ") FILTER (WHERE ");
        get_rule_expr((Node *) aggref->aggfilter, context, false);
    }
 
    appendStringInfoChar(buf, ')');
}

References Aggref::aggdirectargs, Aggref::aggdistinct, Aggref::aggfilter, Aggref::aggfnoid, Aggref::aggorder, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), arg, Aggref::args, Assert(), deparse_context::buf, buf, DO_AGGSPLIT_COMBINE, DO_AGGSPLIT_SKIPFINAL, TargetEntry::expr, FUNC_MAX_ARGS, funcname, generate_function_name(), get_agg_combine_expr(), get_aggregate_argtypes(), get_rule_expr(), get_rule_orderby(), i, IsA, lfirst, linitial_node, list_length(), NIL, resolve_special_varno(), and deparse_context::special_exprkind.

Referenced by get_agg_expr(), and get_json_agg_constructor().

get_basic_select_query()

static void get_basic_select_query ( Query *  query, deparse_context *  context, TupleDesc  resultDesc, bool  colNamesVisible  )

static

Definition at line 5890 of file ruleutils.c.

{
    StringInfo  buf = context->buf;
    RangeTblEntry *values_rte;
    char       *sep;
    ListCell   *l;
 
    if (PRETTY_INDENT(context))
    {
        context->indentLevel += PRETTYINDENT_STD;
        appendStringInfoChar(buf, ' ');
    }
 
    /*
     * If the query looks like SELECT * FROM (VALUES ...), then print just the
     * VALUES part.  This reverses what transformValuesClause() did at parse
     * time.
     */
    values_rte = get_simple_values_rte(query, resultDesc);
    if (values_rte)
    {
        get_values_def(values_rte->values_lists, context);
        return;
    }
 
    /*
     * Build up the query string - first we say SELECT
     */
    if (query->isReturn)
        appendStringInfoString(buf, "RETURN");
    else
        appendStringInfoString(buf, "SELECT");
 
    /* Add the DISTINCT clause if given */
    if (query->distinctClause != NIL)
    {
        if (query->hasDistinctOn)
        {
            appendStringInfoString(buf, " DISTINCT ON (");
            sep = "";
            foreach(l, query->distinctClause)
            {
                SortGroupClause *srt = (SortGroupClause *) lfirst(l);
 
                appendStringInfoString(buf, sep);
                get_rule_sortgroupclause(srt->tleSortGroupRef, query->targetList,
                                         false, context);
                sep = ", ";
            }
            appendStringInfoChar(buf, ')');
        }
        else
            appendStringInfoString(buf, " DISTINCT");
    }
 
    /* Then we tell what to select (the targetlist) */
    get_target_list(query->targetList, context, resultDesc, colNamesVisible);
 
    /* Add the FROM clause if needed */
    get_from_clause(query, " FROM ", context);
 
    /* Add the WHERE clause if given */
    if (query->jointree->quals != NULL)
    {
        appendContextKeyword(context, " WHERE ",
                             -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
        get_rule_expr(query->jointree->quals, context, false);
    }
 
    /* Add the GROUP BY clause if given */
    if (query->groupClause != NULL || query->groupingSets != NULL)
    {
        ParseExprKind save_exprkind;
 
        appendContextKeyword(context, " GROUP BY ",
                             -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
        if (query->groupDistinct)
            appendStringInfoString(buf, "DISTINCT ");
 
        save_exprkind = context->special_exprkind;
        context->special_exprkind = EXPR_KIND_GROUP_BY;
 
        if (query->groupingSets == NIL)
        {
            sep = "";
            foreach(l, query->groupClause)
            {
                SortGroupClause *grp = (SortGroupClause *) lfirst(l);
 
                appendStringInfoString(buf, sep);
                get_rule_sortgroupclause(grp->tleSortGroupRef, query->targetList,
                                         false, context);
                sep = ", ";
            }
        }
        else
        {
            sep = "";
            foreach(l, query->groupingSets)
            {
                GroupingSet *grp = lfirst(l);
 
                appendStringInfoString(buf, sep);
                get_rule_groupingset(grp, query->targetList, true, context);
                sep = ", ";
            }
        }
 
        context->special_exprkind = save_exprkind;
    }
 
    /* Add the HAVING clause if given */
    if (query->havingQual != NULL)
    {
        appendContextKeyword(context, " HAVING ",
                             -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
        get_rule_expr(query->havingQual, context, false);
    }
 
    /* Add the WINDOW clause if needed */
    if (query->windowClause != NIL)
        get_rule_windowclause(query, context);
}

References appendContextKeyword(), appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, Query::distinctClause, EXPR_KIND_GROUP_BY, get_from_clause(), get_rule_expr(), get_rule_groupingset(), get_rule_sortgroupclause(), get_rule_windowclause(), get_simple_values_rte(), get_target_list(), get_values_def(), Query::groupClause, Query::groupDistinct, Query::groupingSets, Query::havingQual, deparse_context::indentLevel, Query::jointree, lfirst, NIL, PRETTY_INDENT, PRETTYINDENT_STD, FromExpr::quals, deparse_context::special_exprkind, Query::targetList, SortGroupClause::tleSortGroupRef, RangeTblEntry::values_lists, and Query::windowClause.

Referenced by get_select_query_def().

get_coercion_expr()

static void get_coercion_expr ( Node *  arg, deparse_context *  context, Oid  resulttype, int32  resulttypmod, Node *  parentNode  )

static

Definition at line 10569 of file ruleutils.c.

{
    StringInfo  buf = context->buf;
 
    /*
     * Since parse_coerce.c doesn't immediately collapse application of
     * length-coercion functions to constants, what we'll typically see in
     * such cases is a Const with typmod -1 and a length-coercion function
     * right above it.  Avoid generating redundant output. However, beware of
     * suppressing casts when the user actually wrote something like
     * 'foo'::text::char(3).
     *
     * Note: it might seem that we are missing the possibility of needing to
     * print a COLLATE clause for such a Const.  However, a Const could only
     * have nondefault collation in a post-constant-folding tree, in which the
     * length coercion would have been folded too.  See also the special
     * handling of CollateExpr in coerce_to_target_type(): any collation
     * marking will be above the coercion node, not below it.
     */
    if (arg && IsA(arg, Const) &&
        ((Const *) arg)->consttype == resulttype &&
        ((Const *) arg)->consttypmod == -1)
    {
        /* Show the constant without normal ::typename decoration */
        get_const_expr((Const *) arg, context, -1);
    }
    else
    {
        if (!PRETTY_PAREN(context))
            appendStringInfoChar(buf, '(');
        get_rule_expr_paren(arg, context, false, parentNode);
        if (!PRETTY_PAREN(context))
            appendStringInfoChar(buf, ')');
    }
 
    /*
     * Never emit resulttype(arg) functional notation. A pg_proc entry could
     * take precedence, and a resulttype in pg_temp would require schema
     * qualification that format_type_with_typemod() would usually omit. We've
     * standardized on arg::resulttype, but CAST(arg AS resulttype) notation
     * would work fine.
     */
    appendStringInfo(buf, "::%s",
                     format_type_with_typemod(resulttype, resulttypmod));
}

References appendStringInfo(), appendStringInfoChar(), arg, deparse_context::buf, buf, format_type_with_typemod(), get_const_expr(), get_rule_expr_paren(), IsA, and PRETTY_PAREN.

Referenced by get_func_expr(), and get_rule_expr().

get_column_alias_list()

static void get_column_alias_list ( deparse_columns *  colinfo, deparse_context *  context  )

static

Definition at line 11662 of file ruleutils.c.

{
    StringInfo  buf = context->buf;
    int         i;
    bool        first = true;
 
    /* Don't print aliases if not needed */
    if (!colinfo->printaliases)
        return;
 
    for (i = 0; i < colinfo->num_new_cols; i++)
    {
        char       *colname = colinfo->new_colnames[i];
 
        if (first)
        {
            appendStringInfoChar(buf, '(');
            first = false;
        }
        else
            appendStringInfoString(buf, ", ");
        appendStringInfoString(buf, quote_identifier(colname));
    }
    if (!first)
        appendStringInfoChar(buf, ')');
}

References appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, i, deparse_columns::new_colnames, deparse_columns::num_new_cols, deparse_columns::printaliases, and quote_identifier().

Referenced by get_from_clause_item().

get_const_collation()

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

static

Definition at line 10763 of file ruleutils.c.

{
    StringInfo  buf = context->buf;
 
    if (OidIsValid(constval->constcollid))
    {
        Oid         typcollation = get_typcollation(constval->consttype);
 
        if (constval->constcollid != typcollation)
        {
            appendStringInfo(buf, " COLLATE %s",
                             generate_collation_name(constval->constcollid));
        }
    }
}

References appendStringInfo(), deparse_context::buf, buf, Const::consttype, generate_collation_name(), get_typcollation(), and OidIsValid.

Referenced by get_const_expr().

get_const_expr()

static void get_const_expr ( Const *  constval, deparse_context *  context, int  showtype  )

static

Definition at line 10633 of file ruleutils.c.

{
    StringInfo  buf = context->buf;
    Oid         typoutput;
    bool        typIsVarlena;
    char       *extval;
    bool        needlabel = false;
 
    if (constval->constisnull)
    {
        /*
         * Always label the type of a NULL constant to prevent misdecisions
         * about type when reparsing.
         */
        appendStringInfoString(buf, "NULL");
        if (showtype >= 0)
        {
            appendStringInfo(buf, "::%s",
                             format_type_with_typemod(constval->consttype,
                                                      constval->consttypmod));
            get_const_collation(constval, context);
        }
        return;
    }
 
    getTypeOutputInfo(constval->consttype,
                      &typoutput, &typIsVarlena);
 
    extval = OidOutputFunctionCall(typoutput, constval->constvalue);
 
    switch (constval->consttype)
    {
        case INT4OID:
 
            /*
             * INT4 can be printed without any decoration, unless it is
             * negative; in that case print it as '-nnn'::integer to ensure
             * that the output will re-parse as a constant, not as a constant
             * plus operator.  In most cases we could get away with printing
             * (-nnn) instead, because of the way that gram.y handles negative
             * literals; but that doesn't work for INT_MIN, and it doesn't
             * seem that much prettier anyway.
             */
            if (extval[0] != '-')
                appendStringInfoString(buf, extval);
            else
            {
                appendStringInfo(buf, "'%s'", extval);
                needlabel = true;   /* we must attach a cast */
            }
            break;
 
        case NUMERICOID:
 
            /*
             * NUMERIC can be printed without quotes if it looks like a float
             * constant (not an integer, and not Infinity or NaN) and doesn't
             * have a leading sign (for the same reason as for INT4).
             */
            if (isdigit((unsigned char) extval[0]) &&
                strcspn(extval, "eE.") != strlen(extval))
            {
                appendStringInfoString(buf, extval);
            }
            else
            {
                appendStringInfo(buf, "'%s'", extval);
                needlabel = true;   /* we must attach a cast */
            }
            break;
 
        case BOOLOID:
            if (strcmp(extval, "t") == 0)
                appendStringInfoString(buf, "true");
            else
                appendStringInfoString(buf, "false");
            break;
 
        default:
            simple_quote_literal(buf, extval);
            break;
    }
 
    pfree(extval);
 
    if (showtype < 0)
        return;
 
    /*
     * For showtype == 0, append ::typename unless the constant will be
     * implicitly typed as the right type when it is read in.
     *
     * XXX this code has to be kept in sync with the behavior of the parser,
     * especially make_const.
     */
    switch (constval->consttype)
    {
        case BOOLOID:
        case UNKNOWNOID:
            /* These types can be left unlabeled */
            needlabel = false;
            break;
        case INT4OID:
            /* We determined above whether a label is needed */
            break;
        case NUMERICOID:
 
            /*
             * Float-looking constants will be typed as numeric, which we
             * checked above; but if there's a nondefault typmod we need to
             * show it.
             */
            needlabel |= (constval->consttypmod >= 0);
            break;
        default:
            needlabel = true;
            break;
    }
    if (needlabel || showtype > 0)
        appendStringInfo(buf, "::%s",
                         format_type_with_typemod(constval->consttype,
                                                  constval->consttypmod));
 
    get_const_collation(constval, context);
}

References appendStringInfo(), appendStringInfoString(), deparse_context::buf, buf, Const::consttype, format_type_with_typemod(), get_const_collation(), getTypeOutputInfo(), OidOutputFunctionCall(), pfree(), and simple_quote_literal().

Referenced by get_coercion_expr(), get_range_partbound_string(), get_rule_expr(), and get_rule_sortgroupclause().

get_delete_query_def()

static void get_delete_query_def ( Query *  query, deparse_context *  context, bool  colNamesVisible  )

static

Definition at line 7036 of file ruleutils.c.

{
    StringInfo  buf = context->buf;
    RangeTblEntry *rte;
 
    /* Insert the WITH clause if given */
    get_with_clause(query, context);
 
    /*
     * Start the query with DELETE FROM relname
     */
    rte = rt_fetch(query->resultRelation, query->rtable);
    Assert(rte->rtekind == RTE_RELATION);
    if (PRETTY_INDENT(context))
    {
        appendStringInfoChar(buf, ' ');
        context->indentLevel += PRETTYINDENT_STD;
    }
    appendStringInfo(buf, "DELETE FROM %s%s",
                     only_marker(rte),
                     generate_relation_name(rte->relid, NIL));
 
    /* Print the relation alias, if needed */
    get_rte_alias(rte, query->resultRelation, false, context);
 
    /* Add the USING clause if given */
    get_from_clause(query, " USING ", context);
 
    /* Add a WHERE clause if given */
    if (query->jointree->quals != NULL)
    {
        appendContextKeyword(context, " WHERE ",
                             -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
        get_rule_expr(query->jointree->quals, context, false);
    }
 
    /* Add RETURNING if present */
    if (query->returningList)
    {
        appendContextKeyword(context, " RETURNING",
                             -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
        get_target_list(query->returningList, context, NULL, colNamesVisible);
    }
}

References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), Assert(), deparse_context::buf, buf, generate_relation_name(), get_from_clause(), get_rte_alias(), get_rule_expr(), get_target_list(), get_with_clause(), deparse_context::indentLevel, Query::jointree, NIL, only_marker, PRETTY_INDENT, PRETTYINDENT_STD, FromExpr::quals, RangeTblEntry::relid, Query::returningList, rt_fetch, Query::rtable, RTE_RELATION, and RangeTblEntry::rtekind.

Referenced by get_query_def().

get_from_clause()

static void get_from_clause ( Query *  query, const char *  prefix, deparse_context *  context  )

static

Definition at line 11206 of file ruleutils.c.

{
    StringInfo  buf = context->buf;
    bool        first = true;
    ListCell   *l;
 
    /*
     * We use the query's jointree as a guide to what to print.  However, we
     * must ignore auto-added RTEs that are marked not inFromCl. (These can
     * only appear at the top level of the jointree, so it's sufficient to
     * check here.)  This check also ensures we ignore the rule pseudo-RTEs
     * for NEW and OLD.
     */
    foreach(l, query->jointree->fromlist)
    {
        Node       *jtnode = (Node *) lfirst(l);
 
        if (IsA(jtnode, RangeTblRef))
        {
            int         varno = ((RangeTblRef *) jtnode)->rtindex;
            RangeTblEntry *rte = rt_fetch(varno, query->rtable);
 
            if (!rte->inFromCl)
                continue;
        }
 
        if (first)
        {
            appendContextKeyword(context, prefix,
                                 -PRETTYINDENT_STD, PRETTYINDENT_STD, 2);
            first = false;
 
            get_from_clause_item(jtnode, query, context);
        }
        else
        {
            StringInfoData itembuf;
 
            appendStringInfoString(buf, ", ");
 
            /*
             * Put the new FROM item's text into itembuf so we can decide
             * after we've got it whether or not it needs to go on a new line.
             */
            initStringInfo(&itembuf);
            context->buf = &itembuf;
 
            get_from_clause_item(jtnode, query, context);
 
            /* Restore context's output buffer */
            context->buf = buf;
 
            /* Consider line-wrapping if enabled */
            if (PRETTY_INDENT(context) && context->wrapColumn >= 0)
            {
                /* Does the new item start with a new line? */
                if (itembuf.len > 0 && itembuf.data[0] == '\n')
                {
                    /* If so, we shouldn't add anything */
                    /* instead, remove any trailing spaces currently in buf */
                    removeStringInfoSpaces(buf);
                }
                else
                {
                    char       *trailing_nl;
 
                    /* Locate the start of the current line in the buffer */
                    trailing_nl = strrchr(buf->data, '\n');
                    if (trailing_nl == NULL)
                        trailing_nl = buf->data;
                    else
                        trailing_nl++;
 
                    /*
                     * Add a newline, plus some indentation, if the new item
                     * would cause an overflow.
                     */
                    if (strlen(trailing_nl) + itembuf.len > context->wrapColumn)
                        appendContextKeyword(context, "", -PRETTYINDENT_STD,
                                             PRETTYINDENT_STD,
                                             PRETTYINDENT_VAR);
                }
            }
 
            /* Add the new item */
            appendBinaryStringInfo(buf, itembuf.data, itembuf.len);
 
            /* clean up */
            pfree(itembuf.data);
        }
    }
}

References appendBinaryStringInfo(), appendContextKeyword(), appendStringInfoString(), deparse_context::buf, buf, StringInfoData::data, FromExpr::fromlist, get_from_clause_item(), RangeTblEntry::inFromCl, initStringInfo(), IsA, Query::jointree, StringInfoData::len, lfirst, pfree(), PRETTY_INDENT, PRETTYINDENT_STD, PRETTYINDENT_VAR, removeStringInfoSpaces(), rt_fetch, Query::rtable, and deparse_context::wrapColumn.

Referenced by get_basic_select_query(), get_delete_query_def(), get_merge_query_def(), and get_update_query_def().

get_from_clause_coldeflist()

static void get_from_clause_coldeflist ( RangeTblFunction *  rtfunc, deparse_columns *  colinfo, deparse_context *  context  )

static

Definition at line 11702 of file ruleutils.c.

{
    StringInfo  buf = context->buf;
    ListCell   *l1;
    ListCell   *l2;
    ListCell   *l3;
    ListCell   *l4;
    int         i;
 
    appendStringInfoChar(buf, '(');
 
    i = 0;
    forfour(l1, rtfunc->funccoltypes,
            l2, rtfunc->funccoltypmods,
            l3, rtfunc->funccolcollations,
            l4, rtfunc->funccolnames)
    {
        Oid         atttypid = lfirst_oid(l1);
        int32       atttypmod = lfirst_int(l2);
        Oid         attcollation = lfirst_oid(l3);
        char       *attname;
 
        if (colinfo)
            attname = colinfo->colnames[i];
        else
            attname = strVal(lfirst(l4));
 
        Assert(attname);        /* shouldn't be any dropped columns here */
 
        if (i > 0)
            appendStringInfoString(buf, ", ");
        appendStringInfo(buf, "%s %s",
                         quote_identifier(attname),
                         format_type_with_typemod(atttypid, atttypmod));
        if (OidIsValid(attcollation) &&
            attcollation != get_typcollation(atttypid))
            appendStringInfo(buf, " COLLATE %s",
                             generate_collation_name(attcollation));
 
        i++;
    }
 
    appendStringInfoChar(buf, ')');
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert(), attname, deparse_context::buf, buf, deparse_columns::colnames, forfour, format_type_with_typemod(), generate_collation_name(), get_typcollation(), i, lfirst, lfirst_int, lfirst_oid, OidIsValid, quote_identifier(), and strVal.

Referenced by get_from_clause_item().

get_from_clause_item()

static void get_from_clause_item ( Node *  jtnode, Query *  query, deparse_context *  context  )

static

Definition at line 11300 of file ruleutils.c.

{
    StringInfo  buf = context->buf;
    deparse_namespace *dpns = (deparse_namespace *) linitial(context->namespaces);
 
    if (IsA(jtnode, RangeTblRef))
    {
        int         varno = ((RangeTblRef *) jtnode)->rtindex;
        RangeTblEntry *rte = rt_fetch(varno, query->rtable);
        deparse_columns *colinfo = deparse_columns_fetch(varno, dpns);
        RangeTblFunction *rtfunc1 = NULL;
 
        if (rte->lateral)
            appendStringInfoString(buf, "LATERAL ");
 
        /* Print the FROM item proper */
        switch (rte->rtekind)
        {
            case RTE_RELATION:
                /* Normal relation RTE */
                appendStringInfo(buf, "%s%s",
                                 only_marker(rte),
                                 generate_relation_name(rte->relid,
                                                        context->namespaces));
                break;
            case RTE_SUBQUERY:
                /* Subquery RTE */
                appendStringInfoChar(buf, '(');
                get_query_def(rte->subquery, buf, context->namespaces, NULL,
                              true,
                              context->prettyFlags, context->wrapColumn,
                              context->indentLevel);
                appendStringInfoChar(buf, ')');
                break;
            case RTE_FUNCTION:
                /* Function RTE */
                rtfunc1 = (RangeTblFunction *) linitial(rte->functions);
 
                /*
                 * Omit ROWS FROM() syntax for just one function, unless it
                 * has both a coldeflist and WITH ORDINALITY. If it has both,
                 * we must use ROWS FROM() syntax to avoid ambiguity about
                 * whether the coldeflist includes the ordinality column.
                 */
                if (list_length(rte->functions) == 1 &&
                    (rtfunc1->funccolnames == NIL || !rte->funcordinality))
                {
                    get_rule_expr_funccall(rtfunc1->funcexpr, context, true);
                    /* we'll print the coldeflist below, if it has one */
                }
                else
                {
                    bool        all_unnest;
                    ListCell   *lc;
 
                    /*
                     * If all the function calls in the list are to unnest,
                     * and none need a coldeflist, then collapse the list back
                     * down to UNNEST(args).  (If we had more than one
                     * built-in unnest function, this would get more
                     * difficult.)
                     *
                     * XXX This is pretty ugly, since it makes not-terribly-
                     * future-proof assumptions about what the parser would do
                     * with the output; but the alternative is to emit our
                     * nonstandard ROWS FROM() notation for what might have
                     * been a perfectly spec-compliant multi-argument
                     * UNNEST().
                     */
                    all_unnest = true;
                    foreach(lc, rte->functions)
                    {
                        RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
 
                        if (!IsA(rtfunc->funcexpr, FuncExpr) ||
                            ((FuncExpr *) rtfunc->funcexpr)->funcid != F_UNNEST_ANYARRAY ||
                            rtfunc->funccolnames != NIL)
                        {
                            all_unnest = false;
                            break;
                        }
                    }
 
                    if (all_unnest)
                    {
                        List       *allargs = NIL;
 
                        foreach(lc, rte->functions)
                        {
                            RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
                            List       *args = ((FuncExpr *) rtfunc->funcexpr)->args;
 
                            allargs = list_concat(allargs, args);
                        }
 
                        appendStringInfoString(buf, "UNNEST(");
                        get_rule_expr((Node *) allargs, context, true);
                        appendStringInfoChar(buf, ')');
                    }
                    else
                    {
                        int         funcno = 0;
 
                        appendStringInfoString(buf, "ROWS FROM(");
                        foreach(lc, rte->functions)
                        {
                            RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
 
                            if (funcno > 0)
                                appendStringInfoString(buf, ", ");
                            get_rule_expr_funccall(rtfunc->funcexpr, context, true);
                            if (rtfunc->funccolnames != NIL)
                            {
                                /* Reconstruct the column definition list */
                                appendStringInfoString(buf, " AS ");
                                get_from_clause_coldeflist(rtfunc,
                                                           NULL,
                                                           context);
                            }
                            funcno++;
                        }
                        appendStringInfoChar(buf, ')');
                    }
                    /* prevent printing duplicate coldeflist below */
                    rtfunc1 = NULL;
                }
                if (rte->funcordinality)
                    appendStringInfoString(buf, " WITH ORDINALITY");
                break;
            case RTE_TABLEFUNC:
                get_tablefunc(rte->tablefunc, context, true);
                break;
            case RTE_VALUES:
                /* Values list RTE */
                appendStringInfoChar(buf, '(');
                get_values_def(rte->values_lists, context);
                appendStringInfoChar(buf, ')');
                break;
            case RTE_CTE:
                appendStringInfoString(buf, quote_identifier(rte->ctename));
                break;
            default:
                elog(ERROR, "unrecognized RTE kind: %d", (int) rte->rtekind);
                break;
        }
 
        /* Print the relation alias, if needed */
        get_rte_alias(rte, varno, false, context);
 
        /* Print the column definitions or aliases, if needed */
        if (rtfunc1 && rtfunc1->funccolnames != NIL)
        {
            /* Reconstruct the columndef list, which is also the aliases */
            get_from_clause_coldeflist(rtfunc1, colinfo, context);
        }
        else
        {
            /* Else print column aliases as needed */
            get_column_alias_list(colinfo, context);
        }
 
        /* Tablesample clause must go after any alias */
        if (rte->rtekind == RTE_RELATION && rte->tablesample)
            get_tablesample_def(rte->tablesample, context);
    }
    else if (IsA(jtnode, JoinExpr))
    {
        JoinExpr   *j = (JoinExpr *) jtnode;
        deparse_columns *colinfo = deparse_columns_fetch(j->rtindex, dpns);
        bool        need_paren_on_right;
 
        need_paren_on_right = PRETTY_PAREN(context) &&
            !IsA(j->rarg, RangeTblRef) &&
            !(IsA(j->rarg, JoinExpr) && ((JoinExpr *) j->rarg)->alias != NULL);
 
        if (!PRETTY_PAREN(context) || j->alias != NULL)
            appendStringInfoChar(buf, '(');
 
        get_from_clause_item(j->larg, query, context);
 
        switch (j->jointype)
        {
            case JOIN_INNER:
                if (j->quals)
                    appendContextKeyword(context, " JOIN ",
                                         -PRETTYINDENT_STD,
                                         PRETTYINDENT_STD,
                                         PRETTYINDENT_JOIN);
                else
                    appendContextKeyword(context, " CROSS JOIN ",
                                         -PRETTYINDENT_STD,
                                         PRETTYINDENT_STD,
                                         PRETTYINDENT_JOIN);
                break;
            case JOIN_LEFT:
                appendContextKeyword(context, " LEFT JOIN ",
                                     -PRETTYINDENT_STD,
                                     PRETTYINDENT_STD,
                                     PRETTYINDENT_JOIN);
                break;
            case JOIN_FULL:
                appendContextKeyword(context, " FULL JOIN ",
                                     -PRETTYINDENT_STD,
                                     PRETTYINDENT_STD,
                                     PRETTYINDENT_JOIN);
                break;
            case JOIN_RIGHT:
                appendContextKeyword(context, " RIGHT JOIN ",
                                     -PRETTYINDENT_STD,
                                     PRETTYINDENT_STD,
                                     PRETTYINDENT_JOIN);
                break;
            default:
                elog(ERROR, "unrecognized join type: %d",
                     (int) j->jointype);
        }
 
        if (need_paren_on_right)
            appendStringInfoChar(buf, '(');
        get_from_clause_item(j->rarg, query, context);
        if (need_paren_on_right)
            appendStringInfoChar(buf, ')');
 
        if (j->usingClause)
        {
            ListCell   *lc;
            bool        first = true;
 
            appendStringInfoString(buf, " USING (");
            /* Use the assigned names, not what's in usingClause */
            foreach(lc, colinfo->usingNames)
            {
                char       *colname = (char *) lfirst(lc);
 
                if (first)
                    first = false;
                else
                    appendStringInfoString(buf, ", ");
                appendStringInfoString(buf, quote_identifier(colname));
            }
            appendStringInfoChar(buf, ')');
 
            if (j->join_using_alias)
                appendStringInfo(buf, " AS %s",
                                 quote_identifier(j->join_using_alias->aliasname));
        }
        else if (j->quals)
        {
            appendStringInfoString(buf, " ON ");
            if (!PRETTY_PAREN(context))
                appendStringInfoChar(buf, '(');
            get_rule_expr(j->quals, context, false);
            if (!PRETTY_PAREN(context))
                appendStringInfoChar(buf, ')');
        }
        else if (j->jointype != JOIN_INNER)
        {
            /* If we didn't say CROSS JOIN above, we must provide an ON */
            appendStringInfoString(buf, " ON TRUE");
        }
 
        if (!PRETTY_PAREN(context) || j->alias != NULL)
            appendStringInfoChar(buf, ')');
 
        /* Yes, it's correct to put alias after the right paren ... */
        if (j->alias != NULL)
        {
            /*
             * Note that it's correct to emit an alias clause if and only if
             * there was one originally.  Otherwise we'd be converting a named
             * join to unnamed or vice versa, which creates semantic
             * subtleties we don't want.  However, we might print a different
             * alias name than was there originally.
             */
            appendStringInfo(buf, " %s",
                             quote_identifier(get_rtable_name(j->rtindex,
                                                              context)));
            get_column_alias_list(colinfo, context);
        }
    }
    else
        elog(ERROR, "unrecognized node type: %d",
             (int) nodeTag(jtnode));
}

References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), generate_unaccent_rules::args, deparse_context::buf, buf, RangeTblEntry::ctename, deparse_columns_fetch, elog(), ERROR, RangeTblFunction::funcexpr, RangeTblEntry::funcordinality, RangeTblEntry::functions, generate_relation_name(), get_column_alias_list(), get_from_clause_coldeflist(), get_query_def(), get_rtable_name(), get_rte_alias(), get_rule_expr(), get_rule_expr_funccall(), get_tablefunc(), get_tablesample_def(), get_values_def(), deparse_context::indentLevel, IsA, j, JOIN_FULL, JOIN_INNER, JOIN_LEFT, JOIN_RIGHT, RangeTblEntry::lateral, lfirst, linitial, list_concat(), list_length(), deparse_context::namespaces, NIL, nodeTag, only_marker, PRETTY_PAREN, deparse_context::prettyFlags, PRETTYINDENT_JOIN, PRETTYINDENT_STD, quote_identifier(), RangeTblEntry::relid, rt_fetch, Query::rtable, RTE_CTE, RTE_FUNCTION, RTE_RELATION, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, RangeTblEntry::rtekind, RangeTblEntry::subquery, RangeTblEntry::tablefunc, RangeTblEntry::tablesample, deparse_columns::usingNames, RangeTblEntry::values_lists, and deparse_context::wrapColumn.

Referenced by get_from_clause().

get_func_expr()

static void get_func_expr ( FuncExpr *  expr, deparse_context *  context, bool  showimplicit  )

static

Definition at line 9973 of file ruleutils.c.

{
    StringInfo  buf = context->buf;
    Oid         funcoid = expr->funcid;
    Oid         argtypes[FUNC_MAX_ARGS];
    int         nargs;
    List       *argnames;
    bool        use_variadic;
    ListCell   *l;
 
    /*
     * If the function call came from an implicit coercion, then just show the
     * first argument --- unless caller wants to see implicit coercions.
     */
    if (expr->funcformat == COERCE_IMPLICIT_CAST && !showimplicit)
    {
        get_rule_expr_paren((Node *) linitial(expr->args), context,
                            false, (Node *) expr);
        return;
    }
 
    /*
     * If the function call came from a cast, then show the first argument
     * plus an explicit cast operation.
     */
    if (expr->funcformat == COERCE_EXPLICIT_CAST ||
        expr->funcformat == COERCE_IMPLICIT_CAST)
    {
        Node       *arg = linitial(expr->args);
        Oid         rettype = expr->funcresulttype;
        int32       coercedTypmod;
 
        /* Get the typmod if this is a length-coercion function */
        (void) exprIsLengthCoercion((Node *) expr, &coercedTypmod);
 
        get_coercion_expr(arg, context,
                          rettype, coercedTypmod,
                          (Node *) expr);
 
        return;
    }
 
    /*
     * If the function was called using one of the SQL spec's random special
     * syntaxes, try to reproduce that.  If we don't recognize the function,
     * fall through.
     */
    if (expr->funcformat == COERCE_SQL_SYNTAX)
    {
        if (get_func_sql_syntax(expr, context))
            return;
    }
 
    /*
     * Normal function: display as proname(args).  First we need to extract
     * the argument datatypes.
     */
    if (list_length(expr->args) > FUNC_MAX_ARGS)
        ereport(ERROR,
                (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
                 errmsg("too many arguments")));
    nargs = 0;
    argnames = NIL;
    foreach(l, expr->args)
    {
        Node       *arg = (Node *) lfirst(l);
 
        if (IsA(arg, NamedArgExpr))
            argnames = lappend(argnames, ((NamedArgExpr *) arg)->name);
        argtypes[nargs] = exprType(arg);
        nargs++;
    }
 
    appendStringInfo(buf, "%s(",
                     generate_function_name(funcoid, nargs,
                                            argnames, argtypes,
                                            expr->funcvariadic,
                                            &use_variadic,
                                            context->special_exprkind));
    nargs = 0;
    foreach(l, expr->args)
    {
        if (nargs++ > 0)
            appendStringInfoString(buf, ", ");
        if (use_variadic && lnext(expr->args, l) == NULL)
            appendStringInfoString(buf, "VARIADIC ");
        get_rule_expr((Node *) lfirst(l), context, true);
    }
    appendStringInfoChar(buf, ')');
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), arg, FuncExpr::args, deparse_context::buf, buf, COERCE_EXPLICIT_CAST, COERCE_IMPLICIT_CAST, COERCE_SQL_SYNTAX, ereport, errcode(), errmsg(), ERROR, exprIsLengthCoercion(), exprType(), FUNC_MAX_ARGS, FuncExpr::funcid, generate_function_name(), get_coercion_expr(), get_func_sql_syntax(), get_rule_expr(), get_rule_expr_paren(), IsA, lappend(), lfirst, linitial, list_length(), lnext(), NIL, and deparse_context::special_exprkind.

Referenced by get_rule_expr().

get_func_sql_syntax()

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

static

Definition at line 10327 of file ruleutils.c.

{
    StringInfo  buf = context->buf;
    Oid         funcoid = expr->funcid;
 
    switch (funcoid)
    {
        case F_TIMEZONE_INTERVAL_TIMESTAMP:
        case F_TIMEZONE_INTERVAL_TIMESTAMPTZ:
        case F_TIMEZONE_INTERVAL_TIMETZ:
        case F_TIMEZONE_TEXT_TIMESTAMP:
        case F_TIMEZONE_TEXT_TIMESTAMPTZ:
        case F_TIMEZONE_TEXT_TIMETZ:
            /* AT TIME ZONE ... note reversed argument order */
            appendStringInfoChar(buf, '(');
            get_rule_expr_paren((Node *) lsecond(expr->args), context, false,
                                (Node *) expr);
            appendStringInfoString(buf, " AT TIME ZONE ");
            get_rule_expr_paren((Node *) linitial(expr->args), context, false,
                                (Node *) expr);
            appendStringInfoChar(buf, ')');
            return true;
 
        case F_OVERLAPS_TIMESTAMPTZ_INTERVAL_TIMESTAMPTZ_INTERVAL:
        case F_OVERLAPS_TIMESTAMPTZ_INTERVAL_TIMESTAMPTZ_TIMESTAMPTZ:
        case F_OVERLAPS_TIMESTAMPTZ_TIMESTAMPTZ_TIMESTAMPTZ_INTERVAL:
        case F_OVERLAPS_TIMESTAMPTZ_TIMESTAMPTZ_TIMESTAMPTZ_TIMESTAMPTZ:
        case F_OVERLAPS_TIMESTAMP_INTERVAL_TIMESTAMP_INTERVAL:
        case F_OVERLAPS_TIMESTAMP_INTERVAL_TIMESTAMP_TIMESTAMP:
        case F_OVERLAPS_TIMESTAMP_TIMESTAMP_TIMESTAMP_INTERVAL:
        case F_OVERLAPS_TIMESTAMP_TIMESTAMP_TIMESTAMP_TIMESTAMP:
        case F_OVERLAPS_TIMETZ_TIMETZ_TIMETZ_TIMETZ:
        case F_OVERLAPS_TIME_INTERVAL_TIME_INTERVAL:
        case F_OVERLAPS_TIME_INTERVAL_TIME_TIME:
        case F_OVERLAPS_TIME_TIME_TIME_INTERVAL:
        case F_OVERLAPS_TIME_TIME_TIME_TIME:
            /* (x1, x2) OVERLAPS (y1, y2) */
            appendStringInfoString(buf, "((");
            get_rule_expr((Node *) linitial(expr->args), context, false);
            appendStringInfoString(buf, ", ");
            get_rule_expr((Node *) lsecond(expr->args), context, false);
            appendStringInfoString(buf, ") OVERLAPS (");
            get_rule_expr((Node *) lthird(expr->args), context, false);
            appendStringInfoString(buf, ", ");
            get_rule_expr((Node *) lfourth(expr->args), context, false);
            appendStringInfoString(buf, "))");
            return true;
 
        case F_EXTRACT_TEXT_DATE:
        case F_EXTRACT_TEXT_TIME:
        case F_EXTRACT_TEXT_TIMETZ:
        case F_EXTRACT_TEXT_TIMESTAMP:
        case F_EXTRACT_TEXT_TIMESTAMPTZ:
        case F_EXTRACT_TEXT_INTERVAL:
            /* EXTRACT (x FROM y) */
            appendStringInfoString(buf, "EXTRACT(");
            {
                Const      *con = (Const *) linitial(expr->args);
 
                Assert(IsA(con, Const) &&
                       con->consttype == TEXTOID &&
                       !con->constisnull);
                appendStringInfoString(buf, TextDatumGetCString(con->constvalue));
            }
            appendStringInfoString(buf, " FROM ");
            get_rule_expr((Node *) lsecond(expr->args), context, false);
            appendStringInfoChar(buf, ')');
            return true;
 
        case F_IS_NORMALIZED:
            /* IS xxx NORMALIZED */
            appendStringInfoString(buf, "(");
            get_rule_expr_paren((Node *) linitial(expr->args), context, false,
                                (Node *) expr);
            appendStringInfoString(buf, " IS");
            if (list_length(expr->args) == 2)
            {
                Const      *con = (Const *) lsecond(expr->args);
 
                Assert(IsA(con, Const) &&
                       con->consttype == TEXTOID &&
                       !con->constisnull);
                appendStringInfo(buf, " %s",
                                 TextDatumGetCString(con->constvalue));
            }
            appendStringInfoString(buf, " NORMALIZED)");
            return true;
 
        case F_PG_COLLATION_FOR:
            /* COLLATION FOR */
            appendStringInfoString(buf, "COLLATION FOR (");
            get_rule_expr((Node *) linitial(expr->args), context, false);
            appendStringInfoChar(buf, ')');
            return true;
 
        case F_NORMALIZE:
            /* NORMALIZE() */
            appendStringInfoString(buf, "NORMALIZE(");
            get_rule_expr((Node *) linitial(expr->args), context, false);
            if (list_length(expr->args) == 2)
            {
                Const      *con = (Const *) lsecond(expr->args);
 
                Assert(IsA(con, Const) &&
                       con->consttype == TEXTOID &&
                       !con->constisnull);
                appendStringInfo(buf, ", %s",
                                 TextDatumGetCString(con->constvalue));
            }
            appendStringInfoChar(buf, ')');
            return true;
 
        case F_OVERLAY_BIT_BIT_INT4:
        case F_OVERLAY_BIT_BIT_INT4_INT4:
        case F_OVERLAY_BYTEA_BYTEA_INT4:
        case F_OVERLAY_BYTEA_BYTEA_INT4_INT4:
        case F_OVERLAY_TEXT_TEXT_INT4:
        case F_OVERLAY_TEXT_TEXT_INT4_INT4:
            /* OVERLAY() */
            appendStringInfoString(buf, "OVERLAY(");
            get_rule_expr((Node *) linitial(expr->args), context, false);
            appendStringInfoString(buf, " PLACING ");
            get_rule_expr((Node *) lsecond(expr->args), context, false);
            appendStringInfoString(buf, " FROM ");
            get_rule_expr((Node *) lthird(expr->args), context, false);
            if (list_length(expr->args) == 4)
            {
                appendStringInfoString(buf, " FOR ");
                get_rule_expr((Node *) lfourth(expr->args), context, false);
            }
            appendStringInfoChar(buf, ')');
            return true;
 
        case F_POSITION_BIT_BIT:
        case F_POSITION_BYTEA_BYTEA:
        case F_POSITION_TEXT_TEXT:
            /* POSITION() ... extra parens since args are b_expr not a_expr */
            appendStringInfoString(buf, "POSITION((");
            get_rule_expr((Node *) lsecond(expr->args), context, false);
            appendStringInfoString(buf, ") IN (");
            get_rule_expr((Node *) linitial(expr->args), context, false);
            appendStringInfoString(buf, "))");
            return true;
 
        case F_SUBSTRING_BIT_INT4:
        case F_SUBSTRING_BIT_INT4_INT4:
        case F_SUBSTRING_BYTEA_INT4:
        case F_SUBSTRING_BYTEA_INT4_INT4:
        case F_SUBSTRING_TEXT_INT4:
        case F_SUBSTRING_TEXT_INT4_INT4:
            /* SUBSTRING FROM/FOR (i.e., integer-position variants) */
            appendStringInfoString(buf, "SUBSTRING(");
            get_rule_expr((Node *) linitial(expr->args), context, false);
            appendStringInfoString(buf, " FROM ");
            get_rule_expr((Node *) lsecond(expr->args), context, false);
            if (list_length(expr->args) == 3)
            {
                appendStringInfoString(buf, " FOR ");
                get_rule_expr((Node *) lthird(expr->args), context, false);
            }
            appendStringInfoChar(buf, ')');
            return true;
 
        case F_SUBSTRING_TEXT_TEXT_TEXT:
            /* SUBSTRING SIMILAR/ESCAPE */
            appendStringInfoString(buf, "SUBSTRING(");
            get_rule_expr((Node *) linitial(expr->args), context, false);
            appendStringInfoString(buf, " SIMILAR ");
            get_rule_expr((Node *) lsecond(expr->args), context, false);
            appendStringInfoString(buf, " ESCAPE ");
            get_rule_expr((Node *) lthird(expr->args), context, false);
            appendStringInfoChar(buf, ')');
            return true;
 
        case F_BTRIM_BYTEA_BYTEA:
        case F_BTRIM_TEXT:
        case F_BTRIM_TEXT_TEXT:
            /* TRIM() */
            appendStringInfoString(buf, "TRIM(BOTH");
            if (list_length(expr->args) == 2)
            {
                appendStringInfoChar(buf, ' ');
                get_rule_expr((Node *) lsecond(expr->args), context, false);
            }
            appendStringInfoString(buf, " FROM ");
            get_rule_expr((Node *) linitial(expr->args), context, false);
            appendStringInfoChar(buf, ')');
            return true;
 
        case F_LTRIM_BYTEA_BYTEA:
        case F_LTRIM_TEXT:
        case F_LTRIM_TEXT_TEXT:
            /* TRIM() */
            appendStringInfoString(buf, "TRIM(LEADING");
            if (list_length(expr->args) == 2)
            {
                appendStringInfoChar(buf, ' ');
                get_rule_expr((Node *) lsecond(expr->args), context, false);
            }
            appendStringInfoString(buf, " FROM ");
            get_rule_expr((Node *) linitial(expr->args), context, false);
            appendStringInfoChar(buf, ')');
            return true;
 
        case F_RTRIM_BYTEA_BYTEA:
        case F_RTRIM_TEXT:
        case F_RTRIM_TEXT_TEXT:
            /* TRIM() */
            appendStringInfoString(buf, "TRIM(TRAILING");
            if (list_length(expr->args) == 2)
            {
                appendStringInfoChar(buf, ' ');
                get_rule_expr((Node *) lsecond(expr->args), context, false);
            }
            appendStringInfoString(buf, " FROM ");
            get_rule_expr((Node *) linitial(expr->args), context, false);
            appendStringInfoChar(buf, ')');
            return true;
 
        case F_SYSTEM_USER:
            appendStringInfoString(buf, "SYSTEM_USER");
            return true;
 
        case F_XMLEXISTS:
            /* XMLEXISTS ... extra parens because args are c_expr */
            appendStringInfoString(buf, "XMLEXISTS((");
            get_rule_expr((Node *) linitial(expr->args), context, false);
            appendStringInfoString(buf, ") PASSING (");
            get_rule_expr((Node *) lsecond(expr->args), context, false);
            appendStringInfoString(buf, "))");
            return true;
    }
    return false;
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), FuncExpr::args, Assert(), deparse_context::buf, buf, Const::consttype, FuncExpr::funcid, get_rule_expr(), get_rule_expr_paren(), IsA, lfourth, linitial, list_length(), lsecond, lthird, and TextDatumGetCString.

Referenced by get_func_expr().

get_insert_query_def()

static void get_insert_query_def ( Query *  query, deparse_context *  context, bool  colNamesVisible  )

static

Definition at line 6610 of file ruleutils.c.

{
    StringInfo  buf = context->buf;
    RangeTblEntry *select_rte = NULL;
    RangeTblEntry *values_rte = NULL;
    RangeTblEntry *rte;
    char       *sep;
    ListCell   *l;
    List       *strippedexprs;
 
    /* Insert the WITH clause if given */
    get_with_clause(query, context);
 
    /*
     * If it's an INSERT ... SELECT or multi-row VALUES, there will be a
     * single RTE for the SELECT or VALUES.  Plain VALUES has neither.
     */
    foreach(l, query->rtable)
    {
        rte = (RangeTblEntry *) lfirst(l);
 
        if (rte->rtekind == RTE_SUBQUERY)
        {
            if (select_rte)
                elog(ERROR, "too many subquery RTEs in INSERT");
            select_rte = rte;
        }
 
        if (rte->rtekind == RTE_VALUES)
        {
            if (values_rte)
                elog(ERROR, "too many values RTEs in INSERT");
            values_rte = rte;
        }
    }
    if (select_rte && values_rte)
        elog(ERROR, "both subquery and values RTEs in INSERT");
 
    /*
     * Start the query with INSERT INTO relname
     */
    rte = rt_fetch(query->resultRelation, query->rtable);
    Assert(rte->rtekind == RTE_RELATION);
 
    if (PRETTY_INDENT(context))
    {
        context->indentLevel += PRETTYINDENT_STD;
        appendStringInfoChar(buf, ' ');
    }
    appendStringInfo(buf, "INSERT INTO %s",
                     generate_relation_name(rte->relid, NIL));
 
    /* Print the relation alias, if needed; INSERT requires explicit AS */
    get_rte_alias(rte, query->resultRelation, true, context);
 
    /* always want a space here */
    appendStringInfoChar(buf, ' ');
 
    /*
     * Add the insert-column-names list.  Any indirection decoration needed on
     * the column names can be inferred from the top targetlist.
     */
    strippedexprs = NIL;
    sep = "";
    if (query->targetList)
        appendStringInfoChar(buf, '(');
    foreach(l, query->targetList)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(l);
 
        if (tle->resjunk)
            continue;           /* ignore junk entries */
 
        appendStringInfoString(buf, sep);
        sep = ", ";
 
        /*
         * Put out name of target column; look in the catalogs, not at
         * tle->resname, since resname will fail to track RENAME.
         */
        appendStringInfoString(buf,
                               quote_identifier(get_attname(rte->relid,
                                                            tle->resno,
                                                            false)));
 
        /*
         * Print any indirection needed (subfields or subscripts), and strip
         * off the top-level nodes representing the indirection assignments.
         * Add the stripped expressions to strippedexprs.  (If it's a
         * single-VALUES statement, the stripped expressions are the VALUES to
         * print below.  Otherwise they're just Vars and not really
         * interesting.)
         */
        strippedexprs = lappend(strippedexprs,
                                processIndirection((Node *) tle->expr,
                                                   context));
    }
    if (query->targetList)
        appendStringInfoString(buf, ") ");
 
    if (query->override)
    {
        if (query->override == OVERRIDING_SYSTEM_VALUE)
            appendStringInfoString(buf, "OVERRIDING SYSTEM VALUE ");
        else if (query->override == OVERRIDING_USER_VALUE)
            appendStringInfoString(buf, "OVERRIDING USER VALUE ");
    }
 
    if (select_rte)
    {
        /* Add the SELECT */
        get_query_def(select_rte->subquery, buf, context->namespaces, NULL,
                      false,
                      context->prettyFlags, context->wrapColumn,
                      context->indentLevel);
    }
    else if (values_rte)
    {
        /* Add the multi-VALUES expression lists */
        get_values_def(values_rte->values_lists, context);
    }
    else if (strippedexprs)
    {
        /* Add the single-VALUES expression list */
        appendContextKeyword(context, "VALUES (",
                             -PRETTYINDENT_STD, PRETTYINDENT_STD, 2);
        get_rule_list_toplevel(strippedexprs, context, false);
        appendStringInfoChar(buf, ')');
    }
    else
    {
        /* No expressions, so it must be DEFAULT VALUES */
        appendStringInfoString(buf, "DEFAULT VALUES");
    }
 
    /* Add ON CONFLICT if present */
    if (query->onConflict)
    {
        OnConflictExpr *confl = query->onConflict;
 
        appendStringInfoString(buf, " ON CONFLICT");
 
        if (confl->arbiterElems)
        {
            /* Add the single-VALUES expression list */
            appendStringInfoChar(buf, '(');
            get_rule_expr((Node *) confl->arbiterElems, context, false);
            appendStringInfoChar(buf, ')');
 
            /* Add a WHERE clause (for partial indexes) if given */
            if (confl->arbiterWhere != NULL)
            {
                bool        save_varprefix;
 
                /*
                 * Force non-prefixing of Vars, since parser assumes that they
                 * belong to target relation.  WHERE clause does not use
                 * InferenceElem, so this is separately required.
                 */
                save_varprefix = context->varprefix;
                context->varprefix = false;
 
                appendContextKeyword(context, " WHERE ",
                                     -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
                get_rule_expr(confl->arbiterWhere, context, false);
 
                context->varprefix = save_varprefix;
            }
        }
        else if (OidIsValid(confl->constraint))
        {
            char       *constraint = get_constraint_name(confl->constraint);
 
            if (!constraint)
                elog(ERROR, "cache lookup failed for constraint %u",
                     confl->constraint);
            appendStringInfo(buf, " ON CONSTRAINT %s",
                             quote_identifier(constraint));
        }
 
        if (confl->action == ONCONFLICT_NOTHING)
        {
            appendStringInfoString(buf, " DO NOTHING");
        }
        else
        {
            appendStringInfoString(buf, " DO UPDATE SET ");
            /* Deparse targetlist */
            get_update_query_targetlist_def(query, confl->onConflictSet,
                                            context, rte);
 
            /* Add a WHERE clause if given */
            if (confl->onConflictWhere != NULL)
            {
                appendContextKeyword(context, " WHERE ",
                                     -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
                get_rule_expr(confl->onConflictWhere, context, false);
            }
        }
    }
 
    /* Add RETURNING if present */
    if (query->returningList)
    {
        appendContextKeyword(context, " RETURNING",
                             -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
        get_target_list(query->returningList, context, NULL, colNamesVisible);
    }
}

References OnConflictExpr::action, appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), OnConflictExpr::arbiterElems, OnConflictExpr::arbiterWhere, Assert(), deparse_context::buf, buf, OnConflictExpr::constraint, elog(), ERROR, TargetEntry::expr, generate_relation_name(), get_attname(), get_constraint_name(), get_query_def(), get_rte_alias(), get_rule_expr(), get_rule_list_toplevel(), get_target_list(), get_update_query_targetlist_def(), get_values_def(), get_with_clause(), deparse_context::indentLevel, lappend(), lfirst, deparse_context::namespaces, NIL, OidIsValid, Query::onConflict, ONCONFLICT_NOTHING, OnConflictExpr::onConflictSet, OnConflictExpr::onConflictWhere, OVERRIDING_SYSTEM_VALUE, OVERRIDING_USER_VALUE, PRETTY_INDENT, deparse_context::prettyFlags, PRETTYINDENT_STD, processIndirection(), quote_identifier(), RangeTblEntry::relid, TargetEntry::resno, Query::returningList, rt_fetch, Query::rtable, RTE_RELATION, RTE_SUBQUERY, RTE_VALUES, RangeTblEntry::rtekind, RangeTblEntry::subquery, Query::targetList, RangeTblEntry::values_lists, deparse_context::varprefix, and deparse_context::wrapColumn.

Referenced by get_query_def().

get_json_agg_constructor()

static void get_json_agg_constructor ( JsonConstructorExpr *  ctor, deparse_context *  context, const char *  funcname, bool  is_json_objectagg  )

static

Definition at line 10924 of file ruleutils.c.

{
    StringInfoData options;
 
    initStringInfo(&options);
    get_json_constructor_options(ctor, &options);
 
    if (IsA(ctor->func, Aggref))
        get_agg_expr_helper((Aggref *) ctor->func, context,
                            (Aggref *) ctor->func,
                            funcname, options.data, is_json_objectagg);
    else if (IsA(ctor->func, WindowFunc))
        get_windowfunc_expr_helper((WindowFunc *) ctor->func, context,
                                   funcname, options.data,
                                   is_json_objectagg);
    else
        elog(ERROR, "invalid JsonConstructorExpr underlying node type: %d",
             nodeTag(ctor->func));
}

References elog(), ERROR, JsonConstructorExpr::func, funcname, get_agg_expr_helper(), get_json_constructor_options(), get_windowfunc_expr_helper(), initStringInfo(), IsA, nodeTag, and options.

Referenced by get_json_constructor().

get_json_constructor()

static void get_json_constructor ( JsonConstructorExpr *  ctor, deparse_context *  context, bool  showimplicit  )

static

Definition at line 10828 of file ruleutils.c.

{
    StringInfo  buf = context->buf;
    const char *funcname;
    bool        is_json_object;
    int         curridx;
    ListCell   *lc;
 
    if (ctor->type == JSCTOR_JSON_OBJECTAGG)
    {
        get_json_agg_constructor(ctor, context, "JSON_OBJECTAGG", true);
        return;
    }
    else if (ctor->type == JSCTOR_JSON_ARRAYAGG)
    {
        get_json_agg_constructor(ctor, context, "JSON_ARRAYAGG", false);
        return;
    }
 
    switch (ctor->type)
    {
        case JSCTOR_JSON_OBJECT:
            funcname = "JSON_OBJECT";
            break;
        case JSCTOR_JSON_ARRAY:
            funcname = "JSON_ARRAY";
            break;
        case JSCTOR_JSON_PARSE:
            funcname = "JSON";
            break;
        case JSCTOR_JSON_SCALAR:
            funcname = "JSON_SCALAR";
            break;
        case JSCTOR_JSON_SERIALIZE:
            funcname = "JSON_SERIALIZE";
            break;
        default:
            elog(ERROR, "invalid JsonConstructorType %d", ctor->type);
    }
 
    appendStringInfo(buf, "%s(", funcname);
 
    is_json_object = ctor->type == JSCTOR_JSON_OBJECT;
    foreach(lc, ctor->args)
    {
        curridx = foreach_current_index(lc);
        if (curridx > 0)
        {
            const char *sep;
 
            sep = (is_json_object && (curridx % 2) != 0) ? " : " : ", ";
            appendStringInfoString(buf, sep);
        }
 
        get_rule_expr((Node *) lfirst(lc), context, true);
    }
 
    get_json_constructor_options(ctor, buf);
    appendStringInfo(buf, ")");
}

References appendStringInfo(), appendStringInfoString(), JsonConstructorExpr::args, deparse_context::buf, buf, elog(), ERROR, foreach_current_index, funcname, get_json_agg_constructor(), get_json_constructor_options(), get_rule_expr(), JSCTOR_JSON_ARRAY, JSCTOR_JSON_ARRAYAGG, JSCTOR_JSON_OBJECT, JSCTOR_JSON_OBJECTAGG, JSCTOR_JSON_PARSE, JSCTOR_JSON_SCALAR, JSCTOR_JSON_SERIALIZE, lfirst, and JsonConstructorExpr::type.

Referenced by get_rule_expr().

get_json_constructor_options()

static void get_json_constructor_options ( JsonConstructorExpr *  ctor, StringInfo  buf  )

static

Definition at line 10894 of file ruleutils.c.

{
    if (ctor->absent_on_null)
    {
        if (ctor->type == JSCTOR_JSON_OBJECT ||
            ctor->type == JSCTOR_JSON_OBJECTAGG)
            appendStringInfoString(buf, " ABSENT ON NULL");
    }
    else
    {
        if (ctor->type == JSCTOR_JSON_ARRAY ||
            ctor->type == JSCTOR_JSON_ARRAYAGG)
            appendStringInfoString(buf, " NULL ON NULL");
    }
 
    if (ctor->unique)
        appendStringInfoString(buf, " WITH UNIQUE KEYS");
 
    /*
     * Append RETURNING clause if needed; JSON() and JSON_SCALAR() don't
     * support one.
     */
    if (ctor->type != JSCTOR_JSON_PARSE && ctor->type != JSCTOR_JSON_SCALAR)
        get_json_returning(ctor->returning, buf, true);
}

References JsonConstructorExpr::absent_on_null, appendStringInfoString(), buf, get_json_returning(), JSCTOR_JSON_ARRAY, JSCTOR_JSON_ARRAYAGG, JSCTOR_JSON_OBJECT, JSCTOR_JSON_OBJECTAGG, JSCTOR_JSON_PARSE, JSCTOR_JSON_SCALAR, JsonConstructorExpr::returning, JsonConstructorExpr::type, and JsonConstructorExpr::unique.

Referenced by get_json_agg_constructor(), and get_json_constructor().

get_json_format()

static void get_json_format ( JsonFormat *  format, StringInfo  buf  )

static

Definition at line 10783 of file ruleutils.c.

{
    if (format->format_type == JS_FORMAT_DEFAULT)
        return;
 
    appendStringInfoString(buf,
                           format->format_type == JS_FORMAT_JSONB ?
                           " FORMAT JSONB" : " FORMAT JSON");
 
    if (format->encoding != JS_ENC_DEFAULT)
    {
        const char *encoding;
 
        encoding =
            format->encoding == JS_ENC_UTF16 ? "UTF16" :
            format->encoding == JS_ENC_UTF32 ? "UTF32" : "UTF8";
 
        appendStringInfo(buf, " ENCODING %s", encoding);
    }
}

References appendStringInfo(), appendStringInfoString(), buf, encoding, format, JS_ENC_DEFAULT, JS_ENC_UTF16, JS_ENC_UTF32, JS_FORMAT_DEFAULT, and JS_FORMAT_JSONB.

Referenced by get_json_returning(), and get_rule_expr().

get_json_returning()

static void get_json_returning ( JsonReturning *  returning, StringInfo  buf, bool  json_format_by_default  )

static

Definition at line 10808 of file ruleutils.c.

{
    if (!OidIsValid(returning->typid))
        return;
 
    appendStringInfo(buf, " RETURNING %s",
                     format_type_with_typemod(returning->typid,
                                              returning->typmod));
 
    if (!json_format_by_default ||
        returning->format->format_type !=
        (returning->typid == JSONBOID ? JS_FORMAT_JSONB : JS_FORMAT_JSON))
        get_json_format(returning->format, buf);
}

References appendStringInfo(), buf, JsonReturning::format, JsonFormat::format_type, format_type_with_typemod(), get_json_format(), JS_FORMAT_JSON, JS_FORMAT_JSONB, OidIsValid, JsonReturning::typid, and JsonReturning::typmod.

Referenced by get_json_constructor_options().

get_merge_query_def()

static void get_merge_query_def ( Query *  query, deparse_context *  context, bool  colNamesVisible  )

static

Definition at line 7088 of file ruleutils.c.

{
    StringInfo  buf = context->buf;
    RangeTblEntry *rte;
    ListCell   *lc;
 
    /* Insert the WITH clause if given */
    get_with_clause(query, context);
 
    /*
     * Start the query with MERGE INTO relname
     */
    rte = rt_fetch(query->resultRelation, query->rtable);
    Assert(rte->rtekind == RTE_RELATION);
    if (PRETTY_INDENT(context))
    {
        appendStringInfoChar(buf, ' ');
        context->indentLevel += PRETTYINDENT_STD;
    }
    appendStringInfo(buf, "MERGE INTO %s%s",
                     only_marker(rte),
                     generate_relation_name(rte->relid, NIL));
 
    /* Print the relation alias, if needed */
    get_rte_alias(rte, query->resultRelation, false, context);
 
    /* Print the source relation and join clause */
    get_from_clause(query, " USING ", context);
    appendContextKeyword(context, " ON ",
                         -PRETTYINDENT_STD, PRETTYINDENT_STD, 2);
    get_rule_expr(query->jointree->quals, context, false);
 
    /* Print each merge action */
    foreach(lc, query->mergeActionList)
    {
        MergeAction *action = lfirst_node(MergeAction, lc);
 
        appendContextKeyword(context, " WHEN ",
                             -PRETTYINDENT_STD, PRETTYINDENT_STD, 2);
        appendStringInfo(buf, "%sMATCHED", action->matched ? "" : "NOT ");
 
        if (action->qual)
        {
            appendContextKeyword(context, " AND ",
                                 -PRETTYINDENT_STD, PRETTYINDENT_STD, 3);
            get_rule_expr(action->qual, context, false);
        }
        appendContextKeyword(context, " THEN ",
                             -PRETTYINDENT_STD, PRETTYINDENT_STD, 3);
 
        if (action->commandType == CMD_INSERT)
        {
            /* This generally matches get_insert_query_def() */
            List       *strippedexprs = NIL;
            const char *sep = "";
            ListCell   *lc2;
 
            appendStringInfoString(buf, "INSERT");
 
            if (action->targetList)
                appendStringInfoString(buf, " (");
            foreach(lc2, action->targetList)
            {
                TargetEntry *tle = (TargetEntry *) lfirst(lc2);
 
                Assert(!tle->resjunk);
 
                appendStringInfoString(buf, sep);
                sep = ", ";
 
                appendStringInfoString(buf,
                                       quote_identifier(get_attname(rte->relid,
                                                                    tle->resno,
                                                                    false)));
                strippedexprs = lappend(strippedexprs,
                                        processIndirection((Node *) tle->expr,
                                                           context));
            }
            if (action->targetList)
                appendStringInfoChar(buf, ')');
 
            if (action->override)
            {
                if (action->override == OVERRIDING_SYSTEM_VALUE)
                    appendStringInfoString(buf, " OVERRIDING SYSTEM VALUE");
                else if (action->override == OVERRIDING_USER_VALUE)
                    appendStringInfoString(buf, " OVERRIDING USER VALUE");
            }
 
            if (strippedexprs)
            {
                appendContextKeyword(context, " VALUES (",
                                     -PRETTYINDENT_STD, PRETTYINDENT_STD, 4);
                get_rule_list_toplevel(strippedexprs, context, false);
                appendStringInfoChar(buf, ')');
            }
            else
                appendStringInfoString(buf, " DEFAULT VALUES");
        }
        else if (action->commandType == CMD_UPDATE)
        {
            appendStringInfoString(buf, "UPDATE SET ");
            get_update_query_targetlist_def(query, action->targetList,
                                            context, rte);
        }
        else if (action->commandType == CMD_DELETE)
            appendStringInfoString(buf, "DELETE");
        else if (action->commandType == CMD_NOTHING)
            appendStringInfoString(buf, "DO NOTHING");
    }
 
    /* No RETURNING support in MERGE yet */
    Assert(query->returningList == NIL);
}

References generate_unaccent_rules::action, appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert(), deparse_context::buf, buf, CMD_DELETE, CMD_INSERT, CMD_NOTHING, CMD_UPDATE, TargetEntry::expr, generate_relation_name(), get_attname(), get_from_clause(), get_rte_alias(), get_rule_expr(), get_rule_list_toplevel(), get_update_query_targetlist_def(), get_with_clause(), deparse_context::indentLevel, Query::jointree, lappend(), lfirst, lfirst_node, Query::mergeActionList, NIL, only_marker, OVERRIDING_SYSTEM_VALUE, OVERRIDING_USER_VALUE, PRETTY_INDENT, PRETTYINDENT_STD, processIndirection(), FromExpr::quals, quote_identifier(), RangeTblEntry::relid, TargetEntry::resno, Query::returningList, rt_fetch, Query::rtable, RTE_RELATION, and RangeTblEntry::rtekind.

Referenced by get_query_def().

get_name_for_var_field()

static const char* get_name_for_var_field ( Var *  var, int  fieldno, int  levelsup, deparse_context *  context  )

static

Definition at line 7618 of file ruleutils.c.

{
    RangeTblEntry *rte;
    AttrNumber  attnum;
    int         netlevelsup;
    deparse_namespace *dpns;
    int         varno;
    AttrNumber  varattno;
    TupleDesc   tupleDesc;
    Node       *expr;
 
    /*
     * If it's a RowExpr that was expanded from a whole-row Var, use the
     * column names attached to it.  (We could let get_expr_result_tupdesc()
     * handle this, but it's much cheaper to just pull out the name we need.)
     */
    if (IsA(var, RowExpr))
    {
        RowExpr    *r = (RowExpr *) var;
 
        if (fieldno > 0 && fieldno <= list_length(r->colnames))
            return strVal(list_nth(r->colnames, fieldno - 1));
    }
 
    /*
     * If it's a Param of type RECORD, try to find what the Param refers to.
     */
    if (IsA(var, Param))
    {
        Param      *param = (Param *) var;
        ListCell   *ancestor_cell;
 
        expr = find_param_referent(param, context, &dpns, &ancestor_cell);
        if (expr)
        {
            /* Found a match, so recurse to decipher the field name */
            deparse_namespace save_dpns;
            const char *result;
 
            push_ancestor_plan(dpns, ancestor_cell, &save_dpns);
            result = get_name_for_var_field((Var *) expr, fieldno,
                                            0, context);
            pop_ancestor_plan(dpns, &save_dpns);
            return result;
        }
    }
 
    /*
     * If it's a Var of type RECORD, we have to find what the Var refers to;
     * if not, we can use get_expr_result_tupdesc().
     */
    if (!IsA(var, Var) ||
        var->vartype != RECORDOID)
    {
        tupleDesc = get_expr_result_tupdesc((Node *) var, false);
        /* Got the tupdesc, so we can extract the field name */
        Assert(fieldno >= 1 && fieldno <= tupleDesc->natts);
        return NameStr(TupleDescAttr(tupleDesc, fieldno - 1)->attname);
    }
 
    /* Find appropriate nesting depth */
    netlevelsup = var->varlevelsup + levelsup;
    if (netlevelsup >= list_length(context->namespaces))
        elog(ERROR, "bogus varlevelsup: %d offset %d",
             var->varlevelsup, levelsup);
    dpns = (deparse_namespace *) list_nth(context->namespaces,
                                          netlevelsup);
 
    /*
     * If we have a syntactic referent for the Var, and we're working from a
     * parse tree, prefer to use the syntactic referent.  Otherwise, fall back
     * on the semantic referent.  (See comments in get_variable().)
     */
    if (var->varnosyn > 0 && dpns->plan == NULL)
    {
        varno = var->varnosyn;
        varattno = var->varattnosyn;
    }
    else
    {
        varno = var->varno;
        varattno = var->varattno;
    }
 
    /*
     * Try to find the relevant RTE in this rtable.  In a plan tree, it's
     * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
     * down into the subplans, or INDEX_VAR, which is resolved similarly.
     *
     * Note: unlike get_variable and resolve_special_varno, we need not worry
     * about inheritance mapping: a child Var should have the same datatype as
     * its parent, and here we're really only interested in the Var's type.
     */
    if (varno >= 1 && varno <= list_length(dpns->rtable))
    {
        rte = rt_fetch(varno, dpns->rtable);
        attnum = varattno;
    }
    else if (varno == OUTER_VAR && dpns->outer_tlist)
    {
        TargetEntry *tle;
        deparse_namespace save_dpns;
        const char *result;
 
        tle = get_tle_by_resno(dpns->outer_tlist, varattno);
        if (!tle)
            elog(ERROR, "bogus varattno for OUTER_VAR var: %d", varattno);
 
        Assert(netlevelsup == 0);
        push_child_plan(dpns, dpns->outer_plan, &save_dpns);
 
        result = get_name_for_var_field((Var *) tle->expr, fieldno,
                                        levelsup, context);
 
        pop_child_plan(dpns, &save_dpns);
        return result;
    }
    else if (varno == INNER_VAR && dpns->inner_tlist)
    {
        TargetEntry *tle;
        deparse_namespace save_dpns;
        const char *result;
 
        tle = get_tle_by_resno(dpns->inner_tlist, varattno);
        if (!tle)
            elog(ERROR, "bogus varattno for INNER_VAR var: %d", varattno);
 
        Assert(netlevelsup == 0);
        push_child_plan(dpns, dpns->inner_plan, &save_dpns);
 
        result = get_name_for_var_field((Var *) tle->expr, fieldno,
                                        levelsup, context);
 
        pop_child_plan(dpns, &save_dpns);
        return result;
    }
    else if (varno == INDEX_VAR && dpns->index_tlist)
    {
        TargetEntry *tle;
        const char *result;
 
        tle = get_tle_by_resno(dpns->index_tlist, varattno);
        if (!tle)
            elog(ERROR, "bogus varattno for INDEX_VAR var: %d", varattno);
 
        Assert(netlevelsup == 0);
 
        result = get_name_for_var_field((Var *) tle->expr, fieldno,
                                        levelsup, context);
 
        return result;
    }
    else
    {
        elog(ERROR, "bogus varno: %d", varno);
        return NULL;            /* keep compiler quiet */
    }
 
    if (attnum == InvalidAttrNumber)
    {
        /* Var is whole-row reference to RTE, so select the right field */
        return get_rte_attribute_name(rte, fieldno);
    }
 
    /*
     * This part has essentially the same logic as the parser's
     * expandRecordVariable() function, but we are dealing with a different
     * representation of the input context, and we only need one field name
     * not a TupleDesc.  Also, we need special cases for finding subquery and
     * CTE subplans when deparsing Plan trees.
     */
    expr = (Node *) var;        /* default if we can't drill down */
 
    switch (rte->rtekind)
    {
        case RTE_RELATION:
        case RTE_VALUES:
        case RTE_NAMEDTUPLESTORE:
        case RTE_RESULT:
 
            /*
             * This case should not occur: a column of a table, values list,
             * or ENR shouldn't have type RECORD.  Fall through and fail (most
             * likely) at the bottom.
             */
            break;
        case RTE_SUBQUERY:
            /* Subselect-in-FROM: examine sub-select's output expr */
            {
                if (rte->subquery)
                {
                    TargetEntry *ste = get_tle_by_resno(rte->subquery->targetList,
                                                        attnum);
 
                    if (ste == NULL || ste->resjunk)
                        elog(ERROR, "subquery %s does not have attribute %d",
                             rte->eref->aliasname, attnum);
                    expr = (Node *) ste->expr;
                    if (IsA(expr, Var))
                    {
                        /*
                         * Recurse into the sub-select to see what its Var
                         * refers to. We have to build an additional level of
                         * namespace to keep in step with varlevelsup in the
                         * subselect; furthermore, the subquery RTE might be
                         * from an outer query level, in which case the
                         * namespace for the subselect must have that outer
                         * level as parent namespace.
                         */
                        List       *save_nslist = context->namespaces;
                        List       *parent_namespaces;
                        deparse_namespace mydpns;
                        const char *result;
 
                        parent_namespaces = list_copy_tail(context->namespaces,
                                                           netlevelsup);
 
                        set_deparse_for_query(&mydpns, rte->subquery,
                                              parent_namespaces);
 
                        context->namespaces = lcons(&mydpns, parent_namespaces);
 
                        result = get_name_for_var_field((Var *) expr, fieldno,
                                                        0, context);
 
                        context->namespaces = save_nslist;
 
                        return result;
                    }
                    /* else fall through to inspect the expression */
                }
                else
                {
                    /*
                     * We're deparsing a Plan tree so we don't have complete
                     * RTE entries (in particular, rte->subquery is NULL). But
                     * the only place we'd see a Var directly referencing a
                     * SUBQUERY RTE is in a SubqueryScan plan node, and we can
                     * look into the child plan's tlist instead.
                     */
                    TargetEntry *tle;
                    deparse_namespace save_dpns;
                    const char *result;
 
                    if (!dpns->inner_plan)
                        elog(ERROR, "failed to find plan for subquery %s",
                             rte->eref->aliasname);
                    tle = get_tle_by_resno(dpns->inner_tlist, attnum);
                    if (!tle)
                        elog(ERROR, "bogus varattno for subquery var: %d",
                             attnum);
                    Assert(netlevelsup == 0);
                    push_child_plan(dpns, dpns->inner_plan, &save_dpns);
 
                    result = get_name_for_var_field((Var *) tle->expr, fieldno,
                                                    levelsup, context);
 
                    pop_child_plan(dpns, &save_dpns);
                    return result;
                }
            }
            break;
        case RTE_JOIN:
            /* Join RTE --- recursively inspect the alias variable */
            if (rte->joinaliasvars == NIL)
                elog(ERROR, "cannot decompile join alias var in plan tree");
            Assert(attnum > 0 && attnum <= list_length(rte->joinaliasvars));
            expr = (Node *) list_nth(rte->joinaliasvars, attnum - 1);
            Assert(expr != NULL);
            /* we intentionally don't strip implicit coercions here */
            if (IsA(expr, Var))
                return get_name_for_var_field((Var *) expr, fieldno,
                                              var->varlevelsup + levelsup,
                                              context);
            /* else fall through to inspect the expression */
            break;
        case RTE_FUNCTION:
        case RTE_TABLEFUNC:
 
            /*
             * We couldn't get here unless a function is declared with one of
             * its result columns as RECORD, which is not allowed.
             */
            break;
        case RTE_CTE:
            /* CTE reference: examine subquery's output expr */
            {
                CommonTableExpr *cte = NULL;
                Index       ctelevelsup;
                ListCell   *lc;
 
                /*
                 * Try to find the referenced CTE using the namespace stack.
                 */
                ctelevelsup = rte->ctelevelsup + netlevelsup;
                if (ctelevelsup >= list_length(context->namespaces))
                    lc = NULL;
                else
                {
                    deparse_namespace *ctedpns;
 
                    ctedpns = (deparse_namespace *)
                        list_nth(context->namespaces, ctelevelsup);
                    foreach(lc, ctedpns->ctes)
                    {
                        cte = (CommonTableExpr *) lfirst(lc);
                        if (strcmp(cte->ctename, rte->ctename) == 0)
                            break;
                    }
                }
                if (lc != NULL)
                {
                    Query      *ctequery = (Query *) cte->ctequery;
                    TargetEntry *ste = get_tle_by_resno(GetCTETargetList(cte),
                                                        attnum);
 
                    if (ste == NULL || ste->resjunk)
                        elog(ERROR, "CTE %s does not have attribute %d",
                             rte->eref->aliasname, attnum);
                    expr = (Node *) ste->expr;
                    if (IsA(expr, Var))
                    {
                        /*
                         * Recurse into the CTE to see what its Var refers to.
                         * We have to build an additional level of namespace
                         * to keep in step with varlevelsup in the CTE;
                         * furthermore it could be an outer CTE (compare
                         * SUBQUERY case above).
                         */
                        List       *save_nslist = context->namespaces;
                        List       *parent_namespaces;
                        deparse_namespace mydpns;
                        const char *result;
 
                        parent_namespaces = list_copy_tail(context->namespaces,
                                                           ctelevelsup);
 
                        set_deparse_for_query(&mydpns, ctequery,
                                              parent_namespaces);
 
                        context->namespaces = lcons(&mydpns, parent_namespaces);
 
                        result = get_name_for_var_field((Var *) expr, fieldno,
                                                        0, context);
 
                        context->namespaces = save_nslist;
 
                        return result;
                    }
                    /* else fall through to inspect the expression */
                }
                else
                {
                    /*
                     * We're deparsing a Plan tree so we don't have a CTE
                     * list.  But the only places we'd see a Var directly
                     * referencing a CTE RTE are in CteScan or WorkTableScan
                     * plan nodes.  For those cases, set_deparse_plan arranged
                     * for dpns->inner_plan to be the plan node that emits the
                     * CTE or RecursiveUnion result, and we can look at its
                     * tlist instead.
                     */
                    TargetEntry *tle;
                    deparse_namespace save_dpns;
                    const char *result;
 
                    if (!dpns->inner_plan)
                        elog(ERROR, "failed to find plan for CTE %s",
                             rte->eref->aliasname);
                    tle = get_tle_by_resno(dpns->inner_tlist, attnum);
                    if (!tle)
                        elog(ERROR, "bogus varattno for subquery var: %d",
                             attnum);
                    Assert(netlevelsup == 0);
                    push_child_plan(dpns, dpns->inner_plan, &save_dpns);
 
                    result = get_name_for_var_field((Var *) tle->expr, fieldno,
                                                    levelsup, context);
 
                    pop_child_plan(dpns, &save_dpns);
                    return result;
                }
            }
            break;
    }
 
    /*
     * We now have an expression we can't expand any more, so see if
     * get_expr_result_tupdesc() can do anything with it.
     */
    tupleDesc = get_expr_result_tupdesc(expr, false);
    /* Got the tupdesc, so we can extract the field name */
    Assert(fieldno >= 1 && fieldno <= tupleDesc->natts);
    return NameStr(TupleDescAttr(tupleDesc, fieldno - 1)->attname);
}

References Alias::aliasname, Assert(), attname, attnum, RangeTblEntry::ctelevelsup, RangeTblEntry::ctename, CommonTableExpr::ctename, CommonTableExpr::ctequery, deparse_namespace::ctes, elog(), RangeTblEntry::eref, ERROR, TargetEntry::expr, find_param_referent(), get_expr_result_tupdesc(), get_rte_attribute_name(), get_tle_by_resno(), GetCTETargetList, if(), deparse_namespace::index_tlist, INDEX_VAR, deparse_namespace::inner_plan, deparse_namespace::inner_tlist, INNER_VAR, InvalidAttrNumber, IsA, RangeTblEntry::joinaliasvars, lcons(), lfirst, list_copy_tail(), list_length(), list_nth(), deparse_context::namespaces, NameStr, NIL, deparse_namespace::outer_plan, deparse_namespace::outer_tlist, OUTER_VAR, deparse_namespace::plan, pop_ancestor_plan(), pop_child_plan(), push_ancestor_plan(), push_child_plan(), rt_fetch, deparse_namespace::rtable, RTE_CTE, RTE_FUNCTION, RTE_JOIN, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, RangeTblEntry::rtekind, set_deparse_for_query(), strVal, RangeTblEntry::subquery, Query::targetList, TupleDescAttr, Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by get_rule_expr().

get_opclass_name()

static void get_opclass_name ( Oid  opclass, Oid  actual_datatype, StringInfo  buf  )

static

Definition at line 11797 of file ruleutils.c.

{
    HeapTuple   ht_opc;
    Form_pg_opclass opcrec;
    char       *opcname;
    char       *nspname;
 
    ht_opc = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclass));
    if (!HeapTupleIsValid(ht_opc))
        elog(ERROR, "cache lookup failed for opclass %u", opclass);
    opcrec = (Form_pg_opclass) GETSTRUCT(ht_opc);
 
    if (!OidIsValid(actual_datatype) ||
        GetDefaultOpClass(actual_datatype, opcrec->opcmethod) != opclass)
    {
        /* Okay, we need the opclass name.  Do we need to qualify it? */
        opcname = NameStr(opcrec->opcname);
        if (OpclassIsVisible(opclass))
            appendStringInfo(buf, " %s", quote_identifier(opcname));
        else
        {
            nspname = get_namespace_name_or_temp(opcrec->opcnamespace);
            appendStringInfo(buf, " %s.%s",
                             quote_identifier(nspname),
                             quote_identifier(opcname));
        }
    }
    ReleaseSysCache(ht_opc);
}

References appendStringInfo(), buf, CLAOID, elog(), ERROR, get_namespace_name_or_temp(), GetDefaultOpClass(), GETSTRUCT, HeapTupleIsValid, NameStr, ObjectIdGetDatum(), OidIsValid, OpclassIsVisible(), quote_identifier(), ReleaseSysCache(), and SearchSysCache1().

Referenced by generate_opclass_name(), get_rule_expr(), pg_get_indexdef_worker(), and pg_get_partkeydef_worker().

get_oper_expr()

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

static

Definition at line 9933 of file ruleutils.c.

{
    StringInfo  buf = context->buf;
    Oid         opno = expr->opno;
    List       *args = expr->args;
 
    if (!PRETTY_PAREN(context))
        appendStringInfoChar(buf, '(');
    if (list_length(args) == 2)
    {
        /* binary operator */
        Node       *arg1 = (Node *) linitial(args);
        Node       *arg2 = (Node *) lsecond(args);
 
        get_rule_expr_paren(arg1, context, true, (Node *) expr);
        appendStringInfo(buf, " %s ",
                         generate_operator_name(opno,
                                                exprType(arg1),
                                                exprType(arg2)));
        get_rule_expr_paren(arg2, context, true, (Node *) expr);
    }
    else
    {
        /* prefix operator */
        Node       *arg = (Node *) linitial(args);
 
        appendStringInfo(buf, "%s ",
                         generate_operator_name(opno,
                                                InvalidOid,
                                                exprType(arg)));
        get_rule_expr_paren(arg, context, true, (Node *) expr);
    }
    if (!PRETTY_PAREN(context))
        appendStringInfoChar(buf, ')');
}

References appendStringInfo(), appendStringInfoChar(), arg, generate_unaccent_rules::args, OpExpr::args, deparse_context::buf, buf, exprType(), generate_operator_name(), get_rule_expr_paren(), InvalidOid, linitial, list_length(), lsecond, OpExpr::opno, and PRETTY_PAREN.

Referenced by get_rule_expr().

get_parameter()

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

static

Definition at line 8134 of file ruleutils.c.

{
    Node       *expr;
    deparse_namespace *dpns;
    ListCell   *ancestor_cell;
 
    /*
     * If it's a PARAM_EXEC parameter, try to locate the expression from which
     * the parameter was computed.  Note that failing to find a referent isn't
     * an error, since the Param might well be a subplan output rather than an
     * input.
     */
    expr = find_param_referent(param, context, &dpns, &ancestor_cell);
    if (expr)
    {
        /* Found a match, so print it */
        deparse_namespace save_dpns;
        bool        save_varprefix;
        bool        need_paren;
 
        /* Switch attention to the ancestor plan node */
        push_ancestor_plan(dpns, ancestor_cell, &save_dpns);
 
        /*
         * Force prefixing of Vars, since they won't belong to the relation
         * being scanned in the original plan node.
         */
        save_varprefix = context->varprefix;
        context->varprefix = true;
 
        /*
         * A Param's expansion is typically a Var, Aggref, GroupingFunc, or
         * upper-level Param, which wouldn't need extra parentheses.
         * Otherwise, insert parens to ensure the expression looks atomic.
         */
        need_paren = !(IsA(expr, Var) ||
                       IsA(expr, Aggref) ||
                       IsA(expr, GroupingFunc) ||
                       IsA(expr, Param));
        if (need_paren)
            appendStringInfoChar(context->buf, '(');
 
        get_rule_expr(expr, context, false);
 
        if (need_paren)
            appendStringInfoChar(context->buf, ')');
 
        context->varprefix = save_varprefix;
 
        pop_ancestor_plan(dpns, &save_dpns);
 
        return;
    }
 
    /*
     * If it's an external parameter, see if the outermost namespace provides
     * function argument names.
     */
    if (param->paramkind == PARAM_EXTERN && context->namespaces != NIL)
    {
        dpns = llast(context->namespaces);
        if (dpns->argnames &&
            param->paramid > 0 &&
            param->paramid <= dpns->numargs)
        {
            char       *argname = dpns->argnames[param->paramid - 1];
 
            if (argname)
            {
                bool        should_qualify = false;
                ListCell   *lc;
 
                /*
                 * Qualify the parameter name if there are any other deparse
                 * namespaces with range tables.  This avoids qualifying in
                 * trivial cases like "RETURN a + b", but makes it safe in all
                 * other cases.
                 */
                foreach(lc, context->namespaces)
                {
                    deparse_namespace *depns = lfirst(lc);
 
                    if (depns->rtable_names != NIL)
                    {
                        should_qualify = true;
                        break;
                    }
                }
                if (should_qualify)
                {
                    appendStringInfoString(context->buf, quote_identifier(dpns->funcname));
                    appendStringInfoChar(context->buf, '.');
                }
 
                appendStringInfoString(context->buf, quote_identifier(argname));
                return;
            }
        }
    }
 
    /*
     * Not PARAM_EXEC, or couldn't find referent: just print $N.
     */
    appendStringInfo(context->buf, "$%d", param->paramid);
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), deparse_namespace::argnames, deparse_context::buf, find_param_referent(), deparse_namespace::funcname, get_rule_expr(), IsA, lfirst, llast, deparse_context::namespaces, NIL, deparse_namespace::numargs, PARAM_EXTERN, Param::paramid, Param::paramkind, pop_ancestor_plan(), push_ancestor_plan(), quote_identifier(), deparse_namespace::rtable_names, and deparse_context::varprefix.

Referenced by get_rule_expr().

get_query_def()

static void get_query_def ( Query *  query, StringInfo  buf, List *  parentnamespace, TupleDesc  resultDesc, bool  colNamesVisible, int  prettyFlags, int  wrapColumn, int  startIndent  )

static

Definition at line 5429 of file ruleutils.c.

{
    deparse_context context;
    deparse_namespace dpns;
 
    /* Guard against excessively long or deeply-nested queries */
    CHECK_FOR_INTERRUPTS();
    check_stack_depth();
 
    /*
     * Before we begin to examine the query, acquire locks on referenced
     * relations, and fix up deleted columns in JOIN RTEs.  This ensures
     * consistent results.  Note we assume it's OK to scribble on the passed
     * querytree!
     *
     * We are only deparsing the query (we are not about to execute it), so we
     * only need AccessShareLock on the relations it mentions.
     */
    AcquireRewriteLocks(query, false, false);
 
    context.buf = buf;
    context.namespaces = lcons(&dpns, list_copy(parentnamespace));
    context.windowClause = NIL;
    context.windowTList = NIL;
    context.varprefix = (parentnamespace != NIL ||
                         list_length(query->rtable) != 1);
    context.prettyFlags = prettyFlags;
    context.wrapColumn = wrapColumn;
    context.indentLevel = startIndent;
    context.special_exprkind = EXPR_KIND_NONE;
    context.appendparents = NULL;
 
    set_deparse_for_query(&dpns, query, parentnamespace);
 
    switch (query->commandType)
    {
        case CMD_SELECT:
            get_select_query_def(query, &context, resultDesc, colNamesVisible);
            break;
 
        case CMD_UPDATE:
            get_update_query_def(query, &context, colNamesVisible);
            break;
 
        case CMD_INSERT:
            get_insert_query_def(query, &context, colNamesVisible);
            break;
 
        case CMD_DELETE:
            get_delete_query_def(query, &context, colNamesVisible);
            break;
 
        case CMD_MERGE:
            get_merge_query_def(query, &context, colNamesVisible);
            break;
 
        case CMD_NOTHING:
            appendStringInfoString(buf, "NOTHING");
            break;
 
        case CMD_UTILITY:
            get_utility_query_def(query, &context);
            break;
 
        default:
            elog(ERROR, "unrecognized query command type: %d",
                 query->commandType);
            break;
    }
}

References AcquireRewriteLocks(), deparse_context::appendparents, appendStringInfoString(), deparse_context::buf, buf, CHECK_FOR_INTERRUPTS, check_stack_depth(), CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_NOTHING, CMD_SELECT, CMD_UPDATE, CMD_UTILITY, Query::commandType, elog(), ERROR, EXPR_KIND_NONE, get_delete_query_def(), get_insert_query_def(), get_merge_query_def(), get_select_query_def(), get_update_query_def(), get_utility_query_def(), deparse_context::indentLevel, lcons(), list_copy(), list_length(), deparse_context::namespaces, NIL, deparse_context::prettyFlags, Query::rtable, set_deparse_for_query(), deparse_context::special_exprkind, deparse_context::varprefix, deparse_context::windowClause, deparse_context::windowTList, and deparse_context::wrapColumn.

Referenced by get_from_clause_item(), get_insert_query_def(), get_setop_query(), get_sublink_expr(), get_with_clause(), make_ruledef(), make_viewdef(), pg_get_querydef(), and print_function_sqlbody().

get_range_partbound_string()

char* get_range_partbound_string

(

List *

bound_datums

)

Definition at line 12610 of file ruleutils.c.

{
    deparse_context context;
    StringInfo  buf = makeStringInfo();
    ListCell   *cell;
    char       *sep;
 
    memset(&context, 0, sizeof(deparse_context));
    context.buf = buf;
 
    appendStringInfoChar(buf, '(');
    sep = "";
    foreach(cell, bound_datums)
    {
        PartitionRangeDatum *datum =
            lfirst_node(PartitionRangeDatum, cell);
 
        appendStringInfoString(buf, sep);
        if (datum->kind == PARTITION_RANGE_DATUM_MINVALUE)
            appendStringInfoString(buf, "MINVALUE");
        else if (datum->kind == PARTITION_RANGE_DATUM_MAXVALUE)
            appendStringInfoString(buf, "MAXVALUE");
        else
        {
            Const      *val = castNode(Const, datum->value);
 
            get_const_expr(val, &context, -1);
        }
        sep = ", ";
    }
    appendStringInfoChar(buf, ')');
 
    return buf->data;
}

References appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, castNode, get_const_expr(), PartitionRangeDatum::kind, lfirst_node, makeStringInfo(), PARTITION_RANGE_DATUM_MAXVALUE, PARTITION_RANGE_DATUM_MINVALUE, val, and PartitionRangeDatum::value.

Referenced by check_new_partition_bound(), and get_rule_expr().

get_relation_name()

static char * get_relation_name ( Oid  relid )

static

Definition at line 12069 of file ruleutils.c.

{
    char       *relname = get_rel_name(relid);
 
    if (!relname)
        elog(ERROR, "cache lookup failed for relation %u", relid);
    return relname;
}

References elog(), ERROR, get_rel_name(), and relname.

Referenced by get_rte_alias(), pg_get_constraintdef_worker(), pg_get_indexdef_worker(), pg_get_partition_constraintdef(), pg_get_partkeydef_worker(), pg_get_statisticsobj_worker(), and pg_get_statisticsobjdef_expressions().

get_reloptions()

static void get_reloptions ( StringInfo  buf, Datum  reloptions  )

static

Definition at line 12522 of file ruleutils.c.

{
    Datum      *options;
    int         noptions;
    int         i;
 
    deconstruct_array_builtin(DatumGetArrayTypeP(reloptions), TEXTOID,
                              &options, NULL, &noptions);
 
    for (i = 0; i < noptions; i++)
    {
        char       *option = TextDatumGetCString(options[i]);
        char       *name;
        char       *separator;
        char       *value;
 
        /*
         * Each array element should have the form name=value.  If the "=" is
         * missing for some reason, treat it like an empty value.
         */
        name = option;
        separator = strchr(option, '=');
        if (separator)
        {
            *separator = '\0';
            value = separator + 1;
        }
        else
            value = "";
 
        if (i > 0)
            appendStringInfoString(buf, ", ");
        appendStringInfo(buf, "%s=", quote_identifier(name));
 
        /*
         * In general we need to quote the value; but to avoid unnecessary
         * clutter, do not quote if it is an identifier that would not need
         * quoting.  (We could also allow numbers, but that is a bit trickier
         * than it looks --- for example, are leading zeroes significant?  We
         * don't want to assume very much here about what custom reloptions
         * might mean.)
         */
        if (quote_identifier(value) == value)
            appendStringInfoString(buf, value);