Department of second thoughts: suppressing implicit casts everywhere in

ruleutils display is not such a great idea.  For arguments of functions
and operators I think we'd better keep the historical behavior of showing
such casts explicitly, to ensure that the function/operator is reparsed
the same way when the rule is reloaded.  This also makes the output of
EXPLAIN less obscurantist about exactly what's happening.

diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index 6bc15b8060a3694ec20103945ffdd27941bfa9de..426e81d220ae00cb8b3dbab27e93a1d6f1c2cc8e 100644 (file)
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.227 2002/09/18 21:35:20 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.228 2002/09/19 22:48:33 tgl Exp $
  *
  *
  * INTERFACE ROUTINES
@@ -1179,7 +1179,7 @@ StoreAttrDefault(Relation rel, AttrNumber attnum, char *adbin)
        adsrc = deparse_expression(expr,
                                                deparse_context_for(RelationGetRelationName(rel),
                                                                                        RelationGetRelid(rel)),
-                                                          false);
+                                                          false, false);
 
        /*
         * Make the pg_attrdef entry.
@@ -1277,7 +1277,7 @@ StoreRelCheck(Relation rel, char *ccname, char *ccbin)
        ccsrc = deparse_expression(expr,
                                                deparse_context_for(RelationGetRelationName(rel),
                                                                                        RelationGetRelid(rel)),
-                                                          false);
+                                                          false, false);
 
        /*
         * Find columns of rel that are used in ccbin

diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 4edc7184214432e0bcc82285e93e13f64f68740b..2478c4f769feea6b40047d6f319a4a26145612a1 100644 (file)
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -5,7 +5,7 @@
  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994-5, Regents of the University of California
  *
- * $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.87 2002/09/04 20:31:15 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.88 2002/09/19 22:48:33 tgl Exp $
  *
  */
 
@@ -682,7 +682,7 @@ show_scan_qual(List *qual, bool is_or_qual, const char *qlabel,
                                                                           NIL);
 
        /* Deparse the expression */
-       exprstr = deparse_expression(node, context, (outercontext != NULL));
+       exprstr = deparse_expression(node, context, (outercontext != NULL), false);
 
        /* And add to str */
        for (i = 0; i < indent; i++)
@@ -729,7 +729,7 @@ show_upper_qual(List *qual, const char *qlabel,
 
        /* Deparse the expression */
        node = (Node *) make_ands_explicit(qual);
-       exprstr = deparse_expression(node, context, (inner_plan != NULL));
+       exprstr = deparse_expression(node, context, (inner_plan != NULL), false);
 
        /* And add to str */
        for (i = 0; i < indent; i++)
@@ -795,8 +795,9 @@ show_sort_keys(List *tlist, int nkeys, const char *qlabel,
 
                        if (target->resdom->reskey == keyno)
                        {
-                               /* Deparse the expression */
-                               exprstr = deparse_expression(target->expr, context, useprefix);
+                               /* Deparse the expression, showing any top-level cast */
+                               exprstr = deparse_expression(target->expr, context,
+                                                                                        useprefix, true);
                                /* And add to str */
                                if (keyno > 1)
                                        appendStringInfo(str, ", ");

diff --git a/src/backend/commands/typecmds.c b/src/backend/commands/typecmds.c
index 165a42b7c3d587df4efee7fe483617b6cada07af..d53f9abb94524310703f928d98a7b7768c49b7dd 100644 (file)
--- a/src/backend/commands/typecmds.c
+++ b/src/backend/commands/typecmds.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/commands/typecmds.c,v 1.13 2002/09/04 20:31:16 momjian Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/commands/typecmds.c,v 1.14 2002/09/19 22:48:33 tgl Exp $
  *
  * DESCRIPTION
  *       The "DefineFoo" routines take the parse tree and pick out the
@@ -514,7 +514,7 @@ DefineDomain(CreateDomainStmt *stmt)
                                defaultValue = deparse_expression(defaultExpr,
                                                                                  deparse_context_for(domainName,
                                                                                                                          InvalidOid),
-                                                                                                 false);
+                                                                                                 false, false);
                                defaultValueBin = nodeToString(defaultExpr);
                                break;
 

diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index 9f21a609f3dfc179d87e9da46ce9e127690b99f7..47f61865fc397af1355ce0e6e89fbddc69c6414c 100644 (file)
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -3,7 +3,7 @@
  *                             back to source text
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.122 2002/09/18 21:35:23 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.123 2002/09/19 22:48:33 tgl Exp $
  *
  *       This software is copyrighted by Jan Wieck - Hamburg.
  *
@@ -147,9 +147,11 @@ static void get_names_for_var(Var *var, deparse_context *context,
                                  char **schemaname, char **refname, char **attname);
 static RangeTblEntry *find_rte_by_refname(const char *refname,
                                        deparse_context *context);
-static void get_rule_expr(Node *node, deparse_context *context);
+static void get_rule_expr(Node *node, deparse_context *context,
+                                                 bool showimplicit);
 static void get_oper_expr(Expr *expr, deparse_context *context);
-static void get_func_expr(Expr *expr, deparse_context *context);
+static void get_func_expr(Expr *expr, deparse_context *context,
+                                                 bool showimplicit);
 static void get_agg_expr(Aggref *aggref, deparse_context *context);
 static Node *strip_type_coercion(Node *expr, Oid resultType);
 static void get_const_expr(Const *constval, deparse_context *context);
@@ -515,7 +517,7 @@ pg_get_indexdef(PG_FUNCTION_ARGS)
                        node = (Node *) make_ands_explicit((List *) node);
                /* Deparse */
                context = deparse_context_for(get_rel_name(indrelid), indrelid);
-               str = deparse_expression(node, context, false);
+               str = deparse_expression(node, context, false, false);
                appendStringInfo(&buf, " WHERE %s", str);
        }
 
@@ -792,7 +794,7 @@ pg_get_expr(PG_FUNCTION_ARGS)
 
        /* Deparse */
        context = deparse_context_for(relname, relid);
-       str = deparse_expression(node, context, false);
+       str = deparse_expression(node, context, false, false);
 
        /* Pass the result back as TEXT */
        result = DatumGetTextP(DirectFunctionCall1(textin,
@@ -850,11 +852,14 @@ pg_get_userbyid(PG_FUNCTION_ARGS)
  *
  * forceprefix is TRUE to force all Vars to be prefixed with their table names.
  *
+ * showimplicit is TRUE to force all implicit casts to be shown explicitly.
+ *
  * The result is a palloc'd string.
  * ----------
  */
 char *
-deparse_expression(Node *expr, List *dpcontext, bool forceprefix)
+deparse_expression(Node *expr, List *dpcontext,
+                                  bool forceprefix, bool showimplicit)
 {
        StringInfoData buf;
        deparse_context context;
@@ -864,7 +869,7 @@ deparse_expression(Node *expr, List *dpcontext, bool forceprefix)
        context.namespaces = dpcontext;
        context.varprefix = forceprefix;
 
-       get_rule_expr(expr, &context);
+       get_rule_expr(expr, &context, showimplicit);
 
        return buf.data;
 }
@@ -1139,7 +1144,7 @@ make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc)
                dpns.outer_varno = dpns.inner_varno = 0;
                dpns.outer_rte = dpns.inner_rte = NULL;
 
-               get_rule_expr(qual, &context);
+               get_rule_expr(qual, &context, false);
        }
 
        appendStringInfo(buf, " DO ");
@@ -1364,7 +1369,7 @@ get_select_query_def(Query *query, deparse_context *context,
        if (query->limitOffset != NULL)
        {
                appendStringInfo(buf, " OFFSET ");
-               get_rule_expr(query->limitOffset, context);
+               get_rule_expr(query->limitOffset, context, false);
        }
        if (query->limitCount != NULL)
        {
@@ -1373,7 +1378,7 @@ get_select_query_def(Query *query, deparse_context *context,
                        ((Const *) query->limitCount)->constisnull)
                        appendStringInfo(buf, "ALL");
                else
-                       get_rule_expr(query->limitCount, context);
+                       get_rule_expr(query->limitCount, context, false);
        }
 }
 
@@ -1429,7 +1434,7 @@ get_basic_select_query(Query *query, deparse_context *context,
                sep = ", ";
                colno++;
 
-               get_rule_expr(tle->expr, context);
+               get_rule_expr(tle->expr, context, true);
 
                /*
                 * Figure out what the result column should be called.  In the
@@ -1469,7 +1474,7 @@ get_basic_select_query(Query *query, deparse_context *context,
        if (query->jointree->quals != NULL)
        {
                appendStringInfo(buf, " WHERE ");
-               get_rule_expr(query->jointree->quals, context);
+               get_rule_expr(query->jointree->quals, context, false);
        }
 
        /* Add the GROUP BY clause if given */
@@ -1492,7 +1497,7 @@ get_basic_select_query(Query *query, deparse_context *context,
        if (query->havingQual != NULL)
        {
                appendStringInfo(buf, " HAVING ");
-               get_rule_expr(query->havingQual, context);
+               get_rule_expr(query->havingQual, context, false);
        }
 }
 
@@ -1573,7 +1578,7 @@ get_rule_sortgroupclause(SortClause *srt, List *tlist, bool force_colno,
                appendStringInfo(buf, "%d", tle->resdom->resno);
        }
        else
-               get_rule_expr(expr, context);
+               get_rule_expr(expr, context, true);
 
        return expr;
 }
@@ -1642,7 +1647,7 @@ get_insert_query_def(Query *query, deparse_context *context)
 
                        appendStringInfo(buf, sep);
                        sep = ", ";
-                       get_rule_expr(tle->expr, context);
+                       get_rule_expr(tle->expr, context, false);
                }
                appendStringInfoChar(buf, ')');
        }
@@ -1692,7 +1697,7 @@ get_update_query_def(Query *query, deparse_context *context)
                if (!tleIsArrayAssign(tle))
                        appendStringInfo(buf, "%s = ",
                                                         quote_identifier(tle->resdom->resname));
-               get_rule_expr(tle->expr, context);
+               get_rule_expr(tle->expr, context, false);
        }
 
        /* Add the FROM clause if needed */
@@ -1702,7 +1707,7 @@ get_update_query_def(Query *query, deparse_context *context)
        if (query->jointree->quals != NULL)
        {
                appendStringInfo(buf, " WHERE ");
-               get_rule_expr(query->jointree->quals, context);
+               get_rule_expr(query->jointree->quals, context, false);
        }
 }
 
@@ -1730,7 +1735,7 @@ get_delete_query_def(Query *query, deparse_context *context)
        if (query->jointree->quals != NULL)
        {
                appendStringInfo(buf, " WHERE ");
-               get_rule_expr(query->jointree->quals, context);
+               get_rule_expr(query->jointree->quals, context, false);
        }
 }
 
@@ -1890,10 +1895,20 @@ find_rte_by_refname(const char *refname, deparse_context *context)
 
 /* ----------
  * get_rule_expr                       - Parse back an expression
+ *
+ * Note: showimplicit determines whether we display any implicit cast that
+ * is present at the top of the expression tree.  It is a passed argument,
+ * not a field of the context struct, because we change the value as we
+ * recurse down into the expression.  In general we suppress implicit casts
+ * when the result type is known with certainty (eg, the arguments of an
+ * OR must be boolean).  We display implicit casts for arguments of functions
+ * and operators, since this is needed to be certain that the same function
+ * or operator will be chosen when the expression is re-parsed.
  * ----------
  */
 static void
-get_rule_expr(Node *node, deparse_context *context)
+get_rule_expr(Node *node, deparse_context *context,
+                         bool showimplicit)
 {
        StringInfo      buf = context->buf;
 
@@ -1966,42 +1981,44 @@ get_rule_expr(Node *node, deparse_context *context)
                                                        Node       *arg1 = (Node *) lfirst(args);
                                                        Node       *arg2 = (Node *) lsecond(args);
 
-                                                       get_rule_expr(arg1, context);
+                                                       get_rule_expr(arg1, context, true);
                                                        appendStringInfo(buf, " IS DISTINCT FROM ");
-                                                       get_rule_expr(arg2, context);
+                                                       get_rule_expr(arg2, context, true);
                                                }
                                                appendStringInfoChar(buf, ')');
                                                break;
 
                                        case FUNC_EXPR:
-                                               get_func_expr(expr, context);
+                                               get_func_expr(expr, context, showimplicit);
                                                break;
 
                                        case OR_EXPR:
                                                appendStringInfoChar(buf, '(');
-                                               get_rule_expr((Node *) lfirst(args), context);
+                                               get_rule_expr((Node *) lfirst(args), context, false);
                                                while ((args = lnext(args)) != NIL)
                                                {
                                                        appendStringInfo(buf, " OR ");
-                                                       get_rule_expr((Node *) lfirst(args), context);
+                                                       get_rule_expr((Node *) lfirst(args), context,
+                                                                                 false);
                                                }
                                                appendStringInfoChar(buf, ')');
                                                break;
 
                                        case AND_EXPR:
                                                appendStringInfoChar(buf, '(');
-                                               get_rule_expr((Node *) lfirst(args), context);
+                                               get_rule_expr((Node *) lfirst(args), context, false);
                                                while ((args = lnext(args)) != NIL)
                                                {
                                                        appendStringInfo(buf, " AND ");
-                                                       get_rule_expr((Node *) lfirst(args), context);
+                                                       get_rule_expr((Node *) lfirst(args), context,
+                                                                                 false);
                                                }
                                                appendStringInfoChar(buf, ')');
                                                break;
 
                                        case NOT_EXPR:
                                                appendStringInfo(buf, "(NOT ");
-                                               get_rule_expr((Node *) lfirst(args), context);
+                                               get_rule_expr((Node *) lfirst(args), context, false);
                                                appendStringInfoChar(buf, ')');
                                                break;
 
@@ -2042,7 +2059,7 @@ get_rule_expr(Node *node, deparse_context *context)
                                 */
                                if (aref->refassgnexpr)
                                        context->varprefix = false;
-                               get_rule_expr(aref->refexpr, context);
+                               get_rule_expr(aref->refexpr, context, showimplicit);
                                context->varprefix = savevarprefix;
                                lowlist = aref->reflowerindexpr;
                                foreach(uplist, aref->refupperindexpr)
@@ -2050,17 +2067,18 @@ get_rule_expr(Node *node, deparse_context *context)
                                        appendStringInfo(buf, "[");
                                        if (lowlist)
                                        {
-                                               get_rule_expr((Node *) lfirst(lowlist), context);
+                                               get_rule_expr((Node *) lfirst(lowlist), context,
+                                                                         false);
                                                appendStringInfo(buf, ":");
                                                lowlist = lnext(lowlist);
                                        }
-                                       get_rule_expr((Node *) lfirst(uplist), context);
+                                       get_rule_expr((Node *) lfirst(uplist), context, false);
                                        appendStringInfo(buf, "]");
                                }
                                if (aref->refassgnexpr)
                                {
                                        appendStringInfo(buf, " = ");
-                                       get_rule_expr(aref->refassgnexpr, context);
+                                       get_rule_expr(aref->refassgnexpr, context, showimplicit);
                                }
                        }
                        break;
@@ -2096,7 +2114,7 @@ get_rule_expr(Node *node, deparse_context *context)
                                 * are *not* simple.  So, always use parenthesized syntax.
                                 */
                                appendStringInfoChar(buf, '(');
-                               get_rule_expr(fselect->arg, context);
+                               get_rule_expr(fselect->arg, context, true);
                                appendStringInfo(buf, ").%s", quote_identifier(fieldname));
                        }
                        break;
@@ -2106,10 +2124,11 @@ get_rule_expr(Node *node, deparse_context *context)
                                RelabelType *relabel = (RelabelType *) node;
                                Node   *arg = relabel->arg;
 
-                               if (relabel->relabelformat == COERCE_IMPLICIT_CAST)
+                               if (relabel->relabelformat == COERCE_IMPLICIT_CAST &&
+                                       !showimplicit)
                                {
-                                       /* don't show an implicit cast */
-                                       get_rule_expr(arg, context);
+                                       /* don't show the implicit cast */
+                                       get_rule_expr(arg, context, showimplicit);
                                }
                                else
                                {
@@ -2122,7 +2141,7 @@ get_rule_expr(Node *node, deparse_context *context)
                                        arg = strip_type_coercion(arg, relabel->resulttype);
 
                                        appendStringInfoChar(buf, '(');
-                                       get_rule_expr(arg, context);
+                                       get_rule_expr(arg, context, showimplicit);
                                        appendStringInfo(buf, ")::%s",
                                                        format_type_with_typemod(relabel->resulttype,
                                                                                                         relabel->resulttypmod));
@@ -2141,12 +2160,12 @@ get_rule_expr(Node *node, deparse_context *context)
                                        CaseWhen   *when = (CaseWhen *) lfirst(temp);
 
                                        appendStringInfo(buf, " WHEN ");
-                                       get_rule_expr(when->expr, context);
+                                       get_rule_expr(when->expr, context, false);
                                        appendStringInfo(buf, " THEN ");
-                                       get_rule_expr(when->result, context);
+                                       get_rule_expr(when->result, context, true);
                                }
                                appendStringInfo(buf, " ELSE ");
-                               get_rule_expr(caseexpr->defresult, context);
+                               get_rule_expr(caseexpr->defresult, context, true);
                                appendStringInfo(buf, " END");
                        }
                        break;
@@ -2156,7 +2175,7 @@ get_rule_expr(Node *node, deparse_context *context)
                                NullTest   *ntest = (NullTest *) node;
 
                                appendStringInfo(buf, "(");
-                               get_rule_expr(ntest->arg, context);
+                               get_rule_expr(ntest->arg, context, true);
                                switch (ntest->nulltesttype)
                                {
                                        case IS_NULL:
@@ -2177,7 +2196,7 @@ get_rule_expr(Node *node, deparse_context *context)
                                BooleanTest *btest = (BooleanTest *) node;
 
                                appendStringInfo(buf, "(");
-                               get_rule_expr(btest->arg, context);
+                               get_rule_expr(btest->arg, context, false);
                                switch (btest->booltesttype)
                                {
                                        case IS_TRUE:
@@ -2213,7 +2232,7 @@ get_rule_expr(Node *node, deparse_context *context)
                                 * We assume that the operations of the constraint node
                                 * need not be explicitly represented in the output.
                                 */
-                               get_rule_expr(ctest->arg, context);
+                               get_rule_expr(ctest->arg, context, showimplicit);
                        }
                        break;
 
@@ -2267,12 +2286,12 @@ get_oper_expr(Expr *expr, deparse_context *context)
                Node       *arg1 = (Node *) lfirst(args);
                Node       *arg2 = (Node *) lsecond(args);
 
-               get_rule_expr(arg1, context);
+               get_rule_expr(arg1, context, true);
                appendStringInfo(buf, " %s ",
                                                 generate_operator_name(opno,
                                                                                                exprType(arg1),
                                                                                                exprType(arg2)));
-               get_rule_expr(arg2, context);
+               get_rule_expr(arg2, context, true);
        }
        else
        {
@@ -2294,10 +2313,10 @@ get_oper_expr(Expr *expr, deparse_context *context)
                                                                 generate_operator_name(opno,
                                                                                                                InvalidOid,
                                                                                                                exprType(arg)));
-                               get_rule_expr(arg, context);
+                               get_rule_expr(arg, context, true);
                                break;
                        case 'r':
-                               get_rule_expr(arg, context);
+                               get_rule_expr(arg, context, true);
                                appendStringInfo(buf, " %s",
                                                                 generate_operator_name(opno,
                                                                                                                exprType(arg),
@@ -2315,7 +2334,8 @@ get_oper_expr(Expr *expr, deparse_context *context)
  * get_func_expr                       - Parse back a Func node
  */
 static void
-get_func_expr(Expr *expr, deparse_context *context)
+get_func_expr(Expr *expr, deparse_context *context,
+                         bool showimplicit)
 {
        StringInfo      buf = context->buf;
        Func       *func = (Func *) (expr->oper);
@@ -2327,19 +2347,20 @@ get_func_expr(Expr *expr, deparse_context *context)
 
        /*
         * If the function call came from an implicit coercion, then just show
-        * the first argument.
+        * the first argument --- unless caller wants to see implicit coercions.
         */
-       if (func->funcformat == COERCE_IMPLICIT_CAST)
+       if (func->funcformat == COERCE_IMPLICIT_CAST && !showimplicit)
        {
-               get_rule_expr((Node *) lfirst(expr->args), context);
+               get_rule_expr((Node *) lfirst(expr->args), context, showimplicit);
                return;
        }
 
        /*
-        * If the function call came from an explicit cast, then show
+        * If the function call came from a cast, then show
         * the first argument plus an explicit cast operation.
         */
-       if (func->funcformat == COERCE_EXPLICIT_CAST)
+       if (func->funcformat == COERCE_EXPLICIT_CAST ||
+               func->funcformat == COERCE_IMPLICIT_CAST)
        {
                Node       *arg = lfirst(expr->args);
                Oid                     rettype = expr->typeOid;
@@ -2357,7 +2378,7 @@ get_func_expr(Expr *expr, deparse_context *context)
                arg = strip_type_coercion(arg, rettype);
 
                appendStringInfoChar(buf, '(');
-               get_rule_expr(arg, context);
+               get_rule_expr(arg, context, showimplicit);
                appendStringInfo(buf, ")::%s",
                                                 format_type_with_typemod(rettype, coercedTypmod));
 
@@ -2384,7 +2405,7 @@ get_func_expr(Expr *expr, deparse_context *context)
        {
                appendStringInfo(buf, sep);
                sep = ", ";
-               get_rule_expr((Node *) lfirst(l), context);
+               get_rule_expr((Node *) lfirst(l), context, true);
        }
        appendStringInfoChar(buf, ')');
 }
@@ -2404,7 +2425,7 @@ get_agg_expr(Aggref *aggref, deparse_context *context)
        if (aggref->aggstar)
                appendStringInfo(buf, "*");
        else
-               get_rule_expr(aggref->target, context);
+               get_rule_expr(aggref->target, context, true);
        appendStringInfoChar(buf, ')');
 }
 
@@ -2618,7 +2639,7 @@ get_sublink_expr(Node *node, deparse_context *context)
                {
                        appendStringInfo(buf, sep);
                        sep = ", ";
-                       get_rule_expr((Node *) lfirst(l), context);
+                       get_rule_expr((Node *) lfirst(l), context, true);
                }
 
                if (need_paren)
@@ -2750,7 +2771,7 @@ get_from_clause_item(Node *jtnode, Query *query, deparse_context *context)
                                break;
                        case RTE_FUNCTION:
                                /* Function RTE */
-                               get_rule_expr(rte->funcexpr, context);
+                               get_rule_expr(rte->funcexpr, context, true);
                                /* might need to emit column list for RECORD function */
                                coldeflist = rte->coldeflist;
                                break;
@@ -2850,7 +2871,7 @@ get_from_clause_item(Node *jtnode, Query *query, deparse_context *context)
                        else if (j->quals)
                        {
                                appendStringInfo(buf, " ON (");
-                               get_rule_expr(j->quals, context);
+                               get_rule_expr(j->quals, context, false);
                                appendStringInfoChar(buf, ')');
                        }
                }

diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h
index d9f611bcfd8dc9ee9b14bb94c095147ccf657899..bfa5fa8efc7de46552c7329aa5a20152f1a6f555 100644 (file)
--- a/src/include/utils/builtins.h
+++ b/src/include/utils/builtins.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: builtins.h,v 1.200 2002/09/18 21:35:24 tgl Exp $
+ * $Id: builtins.h,v 1.201 2002/09/19 22:48:34 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -398,7 +398,7 @@ extern Datum pg_get_constraintdef(PG_FUNCTION_ARGS);
 extern Datum pg_get_userbyid(PG_FUNCTION_ARGS);
 extern Datum pg_get_expr(PG_FUNCTION_ARGS);
 extern char *deparse_expression(Node *expr, List *dpcontext,
-                                  bool forceprefix);
+                                  bool forceprefix, bool showimplicit);
 extern List *deparse_context_for(const char *aliasname, Oid relid);
 extern List *deparse_context_for_plan(int outer_varno, Node *outercontext,
                                                 int inner_varno, Node *innercontext,

diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index a4dfd78cac364ba93ca489b86cea2ae96dc22706..3312dca88a494683323b696cd215962f187f5b22 100644 (file)
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -1271,7 +1271,7 @@ SELECT viewname, definition FROM pg_views ORDER BY viewname;
  pg_locks                 | SELECT l.relation, l."database", l."transaction", l.pid, l."mode", l.granted FROM pg_lock_status() l(relation oid, "database" oid, "transaction" xid, pid integer, "mode" text, granted boolean);
  pg_rules                 | SELECT n.nspname AS schemaname, c.relname AS tablename, r.rulename, pg_get_ruledef(r.oid) AS definition FROM ((pg_rewrite r JOIN pg_class c ON ((c.oid = r.ev_class))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (r.rulename <> '_RETURN'::name);
  pg_settings              | SELECT a.name, a.setting FROM pg_show_all_settings() a(name text, setting text);
- pg_stat_activity         | SELECT d.oid AS datid, d.datname, pg_stat_get_backend_pid(s.backendid) AS procpid, pg_stat_get_backend_userid(s.backendid) AS usesysid, u.usename, pg_stat_get_backend_activity(s.backendid) AS current_query FROM pg_database d, (SELECT pg_stat_get_backend_idset() AS backendid) s, pg_shadow u WHERE ((pg_stat_get_backend_dbid(s.backendid) = d.oid) AND (pg_stat_get_backend_userid(s.backendid) = u.usesysid));
+ pg_stat_activity         | SELECT d.oid AS datid, d.datname, pg_stat_get_backend_pid(s.backendid) AS procpid, pg_stat_get_backend_userid(s.backendid) AS usesysid, u.usename, pg_stat_get_backend_activity(s.backendid) AS current_query FROM pg_database d, (SELECT pg_stat_get_backend_idset() AS backendid) s, pg_shadow u WHERE ((pg_stat_get_backend_dbid(s.backendid) = d.oid) AND (pg_stat_get_backend_userid(s.backendid) = (u.usesysid)::oid));
  pg_stat_all_indexes      | SELECT c.oid AS relid, i.oid AS indexrelid, n.nspname AS schemaname, c.relname, i.relname AS indexrelname, pg_stat_get_numscans(i.oid) AS idx_scan, pg_stat_get_tuples_returned(i.oid) AS idx_tup_read, pg_stat_get_tuples_fetched(i.oid) AS idx_tup_fetch FROM (((pg_class c JOIN pg_index x ON ((c.oid = x.indrelid))) JOIN pg_class i ON ((i.oid = x.indexrelid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (c.relkind = 'r'::"char");
  pg_stat_all_tables       | SELECT c.oid AS relid, n.nspname AS schemaname, c.relname, pg_stat_get_numscans(c.oid) AS seq_scan, pg_stat_get_tuples_returned(c.oid) AS seq_tup_read, sum(pg_stat_get_numscans(i.indexrelid)) AS idx_scan, sum(pg_stat_get_tuples_fetched(i.indexrelid)) AS idx_tup_fetch, pg_stat_get_tuples_inserted(c.oid) AS n_tup_ins, pg_stat_get_tuples_updated(c.oid) AS n_tup_upd, pg_stat_get_tuples_deleted(c.oid) AS n_tup_del FROM ((pg_class c LEFT JOIN pg_index i ON ((c.oid = i.indrelid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (c.relkind = 'r'::"char") GROUP BY c.oid, n.nspname, c.relname;
  pg_stat_database         | SELECT d.oid AS datid, d.datname, pg_stat_get_db_numbackends(d.oid) AS numbackends, pg_stat_get_db_xact_commit(d.oid) AS xact_commit, pg_stat_get_db_xact_rollback(d.oid) AS xact_rollback, (pg_stat_get_db_blocks_fetched(d.oid) - pg_stat_get_db_blocks_hit(d.oid)) AS blks_read, pg_stat_get_db_blocks_hit(d.oid) AS blks_hit FROM pg_database d;