Re: ruleutils with pretty-print option - Mailing list pgsql-patches

From Bruce Momjian
Subject Re: ruleutils with pretty-print option
Date
Msg-id 200307270541.h6R5fkl15016@candle.pha.pa.us
Whole thread Raw
In response to Re: ruleutils with pretty-print option  (Andreas Pflug <pgadmin@pse-consulting.de>)
Responses Re: ruleutils with pretty-print option  (Tom Lane <tgl@sss.pgh.pa.us>)
List pgsql-patches
I am seeing the following regression failures from the patch to allow
pretty printing pg_get_*def functions.

Are these illustrating a problem with the function definition, or is it
happening because it is the first time we are calling the same function
with one and more than one parameter?

In fact, it seems you left the one-parameter versions of these functions
in pg_proc.h.  I don't think that works.  I think you need a wrapper
function for the one-parameter version that calls the two-parameter
version with a valid second parameter value.  I can do the work if you
that is the proper way to handle it, or you can submit a new version.

Also, the patch doesn't apply cleanly to CVS anymore because Tom changed
the elogs in the adt directory.  I can work around that.

I am attaching the regression failures, and an updated version of your
patch.

---------------------------------------------------------------------------

Andreas Pflug wrote:
> Bruce Momjian wrote:
>
> >Andreas, looks good, but I need a diff -c, context diff.
> >
> >
> >
> Hi Bruce,
> I intentionally only attached only non-context diffs because the patch
> is about 50 % size of the original file. Now, here's the same as context
> diff.

--
  Bruce Momjian                        |  http://candle.pha.pa.us
  pgman@candle.pha.pa.us               |  (610) 359-1001
  +  If your life is a hard drive,     |  13 Roberts Road
  +  Christ can be your backup.        |  Newtown Square, Pennsylvania 19073
*** ./expected/opr_sanity.out    Sun Jun 22 18:07:13 2003
--- ./results/opr_sanity.out    Sun Jul 27 01:37:24 2003
***************
*** 85,92 ****
       p1.provolatile != p2.provolatile OR
       p1.pronargs != p2.pronargs);
   oid | proname | oid | proname
! -----+---------+-----+---------
! (0 rows)

  -- Look for uses of different type OIDs in the argument/result type fields
  -- for different aliases of the same built-in function.
--- 85,104 ----
       p1.provolatile != p2.provolatile OR
       p1.pronargs != p2.pronargs);
   oid  |       proname        | oid  |       proname
! ------+----------------------+------+----------------------
!  2504 | pg_get_ruledef       | 1573 | pg_get_ruledef
!  2505 | pg_get_viewdef       | 1640 | pg_get_viewdef
!  2506 | pg_get_viewdef       | 1641 | pg_get_viewdef
!  2507 | pg_get_indexdef      | 1643 | pg_get_indexdef
!  2508 | pg_get_constraintdef | 1387 | pg_get_constraintdef
!  2509 | pg_get_expr          | 1716 | pg_get_expr
!  1716 | pg_get_expr          | 2509 | pg_get_expr
!  1573 | pg_get_ruledef       | 2504 | pg_get_ruledef
!  1640 | pg_get_viewdef       | 2505 | pg_get_viewdef
!  1641 | pg_get_viewdef       | 2506 | pg_get_viewdef
!  1643 | pg_get_indexdef      | 2507 | pg_get_indexdef
!  1387 | pg_get_constraintdef | 2508 | pg_get_constraintdef
! (12 rows)

  -- Look for uses of different type OIDs in the argument/result type fields
  -- for different aliases of the same built-in function.
***************
*** 136,147 ****
      (p1.proargtypes[1] < p2.proargtypes[1]);
   proargtypes | proargtypes
  -------------+-------------
            23 |          28
            25 |        1042
          1114 |        1184
          1560 |        1562
          2277 |        2283
! (5 rows)

  SELECT DISTINCT p1.proargtypes[2], p2.proargtypes[2]
  FROM pg_proc AS p1, pg_proc AS p2
--- 148,161 ----
      (p1.proargtypes[1] < p2.proargtypes[1]);
   proargtypes | proargtypes
  -------------+-------------
+            0 |          16
+            0 |          23
            23 |          28
            25 |        1042
          1114 |        1184
          1560 |        1562
          2277 |        2283
! (7 rows)

  SELECT DISTINCT p1.proargtypes[2], p2.proargtypes[2]
  FROM pg_proc AS p1, pg_proc AS p2
***************
*** 152,159 ****
      (p1.proargtypes[2] < p2.proargtypes[2]);
   proargtypes | proargtypes
  -------------+-------------
          1114 |        1184
! (1 row)

  SELECT DISTINCT p1.proargtypes[3], p2.proargtypes[3]
  FROM pg_proc AS p1, pg_proc AS p2
--- 166,174 ----
      (p1.proargtypes[2] < p2.proargtypes[2]);
   proargtypes | proargtypes
  -------------+-------------
+            0 |          16
          1114 |        1184
! (2 rows)

  SELECT DISTINCT p1.proargtypes[3], p2.proargtypes[3]
  FROM pg_proc AS p1, pg_proc AS p2

======================================================================

*** ./expected/rules.out    Sun Jul 27 00:26:06 2003
--- ./results/rules.out    Sun Jul 27 01:37:42 2003
***************
*** 1314,1320 ****
  SELECT tablename, rulename, definition FROM pg_rules
      ORDER BY tablename, rulename;
     tablename   |    rulename     |
                                             definition
                                                                  
!
---------------+-----------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
   pg_settings   | pg_settings_n   | CREATE RULE pg_settings_n AS ON UPDATE TO pg_settings DO INSTEAD NOTHING;
   pg_settings   | pg_settings_u   | CREATE RULE pg_settings_u AS ON UPDATE TO pg_settings WHERE (new.name = old.name)
DOSELECT set_config(old.name, new.setting, false) AS set_config; 
   rtest_emp     | rtest_emp_del   | CREATE RULE rtest_emp_del AS ON DELETE TO rtest_emp DO INSERT INTO rtest_emplog
(ename,who, "action", newsal, oldsal) VALUES (old.ename, "current_user"(), 'fired'::bpchar, '$0.00'::money,
old.salary);
--- 1314,1320 ----
  SELECT tablename, rulename, definition FROM pg_rules
      ORDER BY tablename, rulename;
     tablename   |    rulename     |
                                             definition
                                                                 
!
---------------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
   pg_settings   | pg_settings_n   | CREATE RULE pg_settings_n ASON UPDATE TO pg_settings DO INSTEAD NOTHING;
   pg_settings   | pg_settings_u   | CREATE RULE pg_settings_u ASON UPDATE TO pg_settings WHERE (new.name = old.name)
DOSELECT set_config(old.name, new.setting, false) AS set_config; 
   rtest_emp     | rtest_emp_del   | CREATE RULE rtest_emp_del ASON DELETE TO rtest_emp DO INSERT INTO rtest_emplog
(ename,who, "action", newsal, oldsal) VALUES (old.ename, "current_user"(), 'fired'::bpchar, '$0.00'::money,
old.salary);

======================================================================

Index: src/backend/utils/adt/ruleutils.c
===================================================================
RCS file: /cvsroot/pgsql-server/src/backend/utils/adt/ruleutils.c,v
retrieving revision 1.146
diff -c -c -r1.146 ruleutils.c
*** src/backend/utils/adt/ruleutils.c    27 Jul 2003 04:53:09 -0000    1.146
--- src/backend/utils/adt/ruleutils.c    27 Jul 2003 05:38:38 -0000
***************
*** 71,76 ****
--- 71,95 ----
  #include "utils/lsyscache.h"


+ /******************************
+  * Pretty formatting constants
+  ******************************/
+
+ /* Indent counts */
+ #define PRETTYINDENT_STD        8
+ #define PRETTYINDENT_JOIN      13
+ #define PRETTYINDENT_JOIN_ON    (PRETTYINDENT_JOIN-PRETTYINDENT_STD)
+ #define PRETTYINDENT_VAR        4
+
+ /* Pretty flags */
+ #define PRETTYFLAG_PAREN        1
+ #define PRETTYFLAG_INDENT       2
+
+ /* macro to test if pretty action needed */
+ #define PRETTY_PAREN(context)   (context->prettyFlags & PRETTYFLAG_PAREN)
+ #define PRETTY_INDENT(context)  (context->prettyFlags & PRETTYFLAG_INDENT)
+
+
  /* ----------
   * Local data types
   * ----------
***************
*** 81,86 ****
--- 100,107 ----
  {
      StringInfo    buf;            /* output buffer to append to */
      List       *namespaces;        /* List of deparse_namespace nodes */
+         int             prettyFlags;            /* enabling/disabling of pretty-print functions */
+         int             indentLevel;            /* for prettyPrint, current space indents are counted */
      bool        varprefix;        /* TRUE to print prefixes on Vars */
  } deparse_context;

***************
*** 123,135 ****
   * as a parameter, and append their text output to its contents.
   * ----------
   */
! static text *pg_do_getviewdef(Oid viewoid);
  static void decompile_column_index_array(Datum column_index_array, Oid relId,
                               StringInfo buf);
! static void make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc);
! static void make_viewdef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc);
  static void get_query_def(Query *query, StringInfo buf, List *parentnamespace,
!               TupleDesc resultDesc);
  static void get_select_query_def(Query *query, deparse_context *context,
                       TupleDesc resultDesc);
  static void get_insert_query_def(Query *query, deparse_context *context);
--- 144,162 ----
   * as a parameter, and append their text output to its contents.
   * ----------
   */
! static char *get_simple_binary_op_name(OpExpr *expr);
! static void appendStringInfoSpace(StringInfo buf, int count);
! static void appendContextKeyword(deparse_context *context, char *str, int indentBefore, int indentAfter, int
indentPlus);
! static char *deparse_expression_pretty(Node *expr, List *dpcontext,
!               bool forceprefix, bool showimplicit, int prettyFlags, int startIndent);
! static bool isSimpleNode(Node *node, Node *parentNode, int prettyFlags);
! static text *pg_do_getviewdef(Oid viewoid, int prettyFlags);
  static void decompile_column_index_array(Datum column_index_array, Oid relId,
                               StringInfo buf);
! static void make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, int prettyFlags);
! static void make_viewdef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, int prettyFlags);
  static void get_query_def(Query *query, StringInfo buf, List *parentnamespace,
!               TupleDesc resultDesc, int prettyFlags, int startIndent);
  static void get_select_query_def(Query *query, deparse_context *context,
                       TupleDesc resultDesc);
  static void get_insert_query_def(Query *query, deparse_context *context);
***************
*** 192,197 ****
--- 219,225 ----
      TupleDesc    rulettc;
      StringInfoData buf;
      int            len;
+     int             prettyFlags = !PG_ARGISNULL(1) && PG_GETARG_BOOL(1) ? PRETTYFLAG_PAREN|PRETTYFLAG_INDENT : 0;

      /*
       * Connect to SPI manager
***************
*** 241,247 ****
       * Get the rules definition and put it into executors memory
       */
      initStringInfo(&buf);
!     make_ruledef(&buf, ruletup, rulettc);
      len = buf.len + VARHDRSZ;
      ruledef = SPI_palloc(len);
      VARATT_SIZEP(ruledef) = len;
--- 269,275 ----
       * Get the rules definition and put it into executors memory
       */
      initStringInfo(&buf);
!     make_ruledef(&buf, ruletup, rulettc, prettyFlags);
      len = buf.len + VARHDRSZ;
      ruledef = SPI_palloc(len);
      VARATT_SIZEP(ruledef) = len;
***************
*** 272,279 ****
      /* By OID */
      Oid            viewoid = PG_GETARG_OID(0);
      text       *ruledef;

!     ruledef = pg_do_getviewdef(viewoid);
      PG_RETURN_TEXT_P(ruledef);
  }

--- 300,308 ----
      /* By OID */
      Oid            viewoid = PG_GETARG_OID(0);
      text       *ruledef;
+     int             prettyFlags = !PG_ARGISNULL(1) && PG_GETARG_BOOL(1) ? PRETTYFLAG_PAREN|PRETTYFLAG_INDENT : 0;

!     ruledef = pg_do_getviewdef(viewoid, prettyFlags);
      PG_RETURN_TEXT_P(ruledef);
  }

***************
*** 285,296 ****
      RangeVar   *viewrel;
      Oid            viewoid;
      text       *ruledef;

      viewrel = makeRangeVarFromNameList(textToQualifiedNameList(viewname,
                                                           "get_viewdef"));
      viewoid = RangeVarGetRelid(viewrel, false);

!     ruledef = pg_do_getviewdef(viewoid);
      PG_RETURN_TEXT_P(ruledef);
  }

--- 314,326 ----
      RangeVar   *viewrel;
      Oid            viewoid;
      text       *ruledef;
+     int             prettyFlags = !PG_ARGISNULL(1) && PG_GETARG_BOOL(1) ? PRETTYFLAG_PAREN|PRETTYFLAG_INDENT : 0;

      viewrel = makeRangeVarFromNameList(textToQualifiedNameList(viewname,
                                                           "get_viewdef"));
      viewoid = RangeVarGetRelid(viewrel, false);

!     ruledef = pg_do_getviewdef(viewoid, prettyFlags);
      PG_RETURN_TEXT_P(ruledef);
  }

***************
*** 298,304 ****
   * Common code for by-OID and by-name variants of pg_get_viewdef
   */
  static text *
! pg_do_getviewdef(Oid viewoid)
  {
      text       *ruledef;
      Datum        args[2];
--- 328,334 ----
   * Common code for by-OID and by-name variants of pg_get_viewdef
   */
  static text *
! pg_do_getviewdef(Oid viewoid, int prettyFlags)
  {
      text       *ruledef;
      Datum        args[2];
***************
*** 353,359 ****
           */
          ruletup = SPI_tuptable->vals[0];
          rulettc = SPI_tuptable->tupdesc;
!         make_viewdef(&buf, ruletup, rulettc);
      }
      len = buf.len + VARHDRSZ;
      ruledef = SPI_palloc(len);
--- 383,389 ----
           */
          ruletup = SPI_tuptable->vals[0];
          rulettc = SPI_tuptable->tupdesc;
!         make_viewdef(&buf, ruletup, rulettc, prettyFlags);
      }
      len = buf.len + VARHDRSZ;
      ruledef = SPI_palloc(len);
***************
*** 543,548 ****
--- 573,580 ----
      StringInfoData buf;
      char       *str;
      char       *sep;
+     int        colno = PG_ARGISNULL(1) ? 0 : PG_GETARG_INT32(1);
+     int        prettyFlags = !PG_ARGISNULL(2) && PG_GETARG_BOOL(2) ? PRETTYFLAG_PAREN|PRETTYFLAG_INDENT : 0;

      /*
       * Fetch the pg_index tuple by the Oid of the index
***************
*** 582,587 ****
--- 614,621 ----
       * Get the index expressions, if any.  (NOTE: we do not use the relcache
       * versions of the expressions and predicate, because we want to display
       * non-const-folded expressions.)
+          * if colno == 0, we want a complete index definition.
+          * if colno > 0, we only want the nth expression.
       */
      if (!heap_attisnull(ht_idx, Anum_pg_index_indexprs))
      {
***************
*** 607,613 ****
       * never be schema-qualified, but the indexed rel's name may be.
       */
      initStringInfo(&buf);
!     appendStringInfo(&buf, "CREATE %sINDEX %s ON %s USING %s (",
                       idxrec->indisunique ? "UNIQUE " : "",
                       quote_identifier(NameStr(idxrelrec->relname)),
                       generate_relation_name(indrelid),
--- 641,649 ----
       * never be schema-qualified, but the indexed rel's name may be.
       */
      initStringInfo(&buf);
!
!     if (!colno)
!         appendStringInfo(&buf, "CREATE %sINDEX %s ON %s USING %s (",
                       idxrec->indisunique ? "UNIQUE " : "",
                       quote_identifier(NameStr(idxrelrec->relname)),
                       generate_relation_name(indrelid),
***************
*** 621,627 ****
      {
          AttrNumber    attnum = idxrec->indkey[keyno];

!         appendStringInfo(&buf, sep);
          sep = ", ";

          if (attnum != 0)
--- 657,664 ----
      {
          AttrNumber    attnum = idxrec->indkey[keyno];

!         if (!colno)
!             appendStringInfo(&buf, sep);
          sep = ", ";

          if (attnum != 0)
***************
*** 630,636 ****
              char       *attname;

              attname = get_relid_attribute_name(indrelid, attnum);
!             appendStringInfo(&buf, "%s", quote_identifier(attname));
              keycoltype = get_atttype(indrelid, attnum);
          }
          else
--- 667,674 ----
              char       *attname;

              attname = get_relid_attribute_name(indrelid, attnum);
!             if (!colno || colno == keyno+1)
!                 appendStringInfo(&buf, "%s", quote_identifier(attname));
              keycoltype = get_atttype(indrelid, attnum);
          }
          else
***************
*** 643,672 ****
              indexkey = (Node *) lfirst(indexprs);
              indexprs = lnext(indexprs);
              /* Deparse */
!             str = deparse_expression(indexkey, context, false, false);
!             /* Need parens if it's not a bare function call */
!             if (indexkey && IsA(indexkey, FuncExpr) &&
                  ((FuncExpr *) indexkey)->funcformat == COERCE_EXPLICIT_CALL)
                  appendStringInfo(&buf, "%s", str);
!             else
                  appendStringInfo(&buf, "(%s)", str);
              keycoltype = exprType(indexkey);
          }

          /*
           * Add the operator class name
           */
!         get_opclass_name(idxrec->indclass[keyno], keycoltype,
                           &buf);
      }

!     appendStringInfoChar(&buf, ')');
!
!     /*
!      * If it's a partial index, decompile and append the predicate
!      */
!     if (!heap_attisnull(ht_idx, Anum_pg_index_indpred))
      {
          Node       *node;
          Datum        predDatum;
          bool        isnull;
--- 681,716 ----
              indexkey = (Node *) lfirst(indexprs);
              indexprs = lnext(indexprs);
              /* Deparse */
!             str = deparse_expression_pretty(indexkey, context, false, false, prettyFlags, 0);
!             if (!colno || colno == keyno+1)
!             {
!                 /* Need parens if it's not a bare function call */
!                 if (indexkey && IsA(indexkey, FuncExpr) &&
                  ((FuncExpr *) indexkey)->funcformat == COERCE_EXPLICIT_CALL)
                  appendStringInfo(&buf, "%s", str);
!                 else
                  appendStringInfo(&buf, "(%s)", str);
+             }
              keycoltype = exprType(indexkey);
          }

          /*
           * Add the operator class name
           */
!         if (!colno)
!             get_opclass_name(idxrec->indclass[keyno], keycoltype,
                           &buf);
      }

!     if (!colno)
      {
+         appendStringInfoChar(&buf, ')');
+
+         /*
+          * If it's a partial index, decompile and append the predicate
+          */
+         if (!heap_attisnull(ht_idx, Anum_pg_index_indpred))
+         {
          Node       *node;
          Datum        predDatum;
          bool        isnull;
***************
*** 689,698 ****
          if (node && IsA(node, List))
              node = (Node *) make_ands_explicit((List *) node);
          /* Deparse */
!         str = deparse_expression(node, context, false, false);
          appendStringInfo(&buf, " WHERE %s", str);
      }
-
      /*
       * Create the result as a TEXT datum, and free working data
       */
--- 733,742 ----
          if (node && IsA(node, List))
              node = (Node *) make_ands_explicit((List *) node);
          /* Deparse */
!         str = deparse_expression_pretty(node, context, false, false, prettyFlags, 0);
          appendStringInfo(&buf, " WHERE %s", str);
+         }
      }
      /*
       * Create the result as a TEXT datum, and free working data
       */
***************
*** 729,734 ****
--- 773,779 ----
      ScanKeyData skey[1];
      HeapTuple    tup;
      Form_pg_constraint conForm;
+     int      prettyFlags = !PG_ARGISNULL(1) && PG_GETARG_BOOL(1) ? PRETTYFLAG_PAREN|PRETTYFLAG_INDENT : 0;

      /*
       * Fetch the pg_constraint row.  There's no syscache for pg_constraint
***************
*** 934,940 ****
                      context = deparse_context_for(get_typname(conForm->contypid),
                                                    InvalidOid);

!                 consrc = deparse_expression(expr, context, false, false);

                  /* Append the constraint source */
                  appendStringInfoString(&buf, consrc);
--- 979,985 ----
                      context = deparse_context_for(get_typname(conForm->contypid),
                                                    InvalidOid);

!                 consrc = deparse_expression_pretty(expr, context, false, false, prettyFlags, 0);

                  /* Append the constraint source */
                  appendStringInfoString(&buf, consrc);
***************
*** 1020,1025 ****
--- 1065,1071 ----
      char       *exprstr;
      char       *relname;
      char       *str;
+     int      prettyFlags = !PG_ARGISNULL(2) && PG_GETARG_BOOL(2) ? PRETTYFLAG_PAREN|PRETTYFLAG_INDENT : 0;

      /* Get the name for the relation */
      relname = get_rel_name(relid);
***************
*** 1043,1049 ****

      /* Deparse */
      context = deparse_context_for(relname, relid);
!     str = deparse_expression(node, context, false, false);

      /* Pass the result back as TEXT */
      result = DatumGetTextP(DirectFunctionCall1(textin,
--- 1089,1095 ----

      /* Deparse */
      context = deparse_context_for(relname, relid);
!     str = deparse_expression_pretty(node, context, false, false, prettyFlags, 0);

      /* Pass the result back as TEXT */
      result = DatumGetTextP(DirectFunctionCall1(textin,
***************
*** 1092,1097 ****
--- 1138,1154 ----

  /* ----------
   * deparse_expression            - General utility for deparsing expressions
+  * calls deparse_expression_pretty with all prettyPrinting disabled
+  */
+ char *
+ deparse_expression(Node *expr, List *dpcontext,
+            bool forceprefix, bool showimplicit)
+ {
+     return deparse_expression_pretty(expr, dpcontext, forceprefix, showimplicit, 0, 0);
+ }
+
+ /* ----------
+  * deparse_expression_pretty            - General utility for deparsing expressions
   *
   * expr is the node tree to be deparsed.  It must be a transformed expression
   * tree (ie, not the raw output of gram.y).
***************
*** 1102,1114 ****
   * 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, bool showimplicit)
  {
      StringInfoData buf;
      deparse_context context;
--- 1159,1173 ----
   * 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.
+  *
+  * tries to pretty up the output according to prettyFlags
   *
   * The result is a palloc'd string.
   * ----------
   */
  char *
! deparse_expression_pretty(Node *expr, List *dpcontext,
!                    bool forceprefix, bool showimplicit, int prettyFlags, int startIndent)
  {
      StringInfoData buf;
      deparse_context context;
***************
*** 1117,1122 ****
--- 1176,1183 ----
      context.buf = &buf;
      context.namespaces = dpcontext;
      context.varprefix = forceprefix;
+     context.prettyFlags = prettyFlags;
+     context.indentLevel = startIndent;

      get_rule_expr(expr, &context, showimplicit);

***************
*** 1269,1275 ****
   * ----------
   */
  static void
! make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc)
  {
      char       *rulename;
      char        ev_type;
--- 1330,1336 ----
   * ----------
   */
  static void
! make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, int prettyFlags)
  {
      char       *rulename;
      char        ev_type;
***************
*** 1323,1331 ****
      /*
       * Build the rules definition text
       */
!     appendStringInfo(buf, "CREATE RULE %s AS ON ",
                       quote_identifier(rulename));

      /* The event the rule is fired for */
      switch (ev_type)
      {
--- 1384,1397 ----
      /*
       * Build the rules definition text
       */
!     appendStringInfo(buf, "CREATE RULE %s AS",
                       quote_identifier(rulename));

+     if (prettyFlags & PRETTYFLAG_INDENT)
+         appendStringInfoString(buf, "\n    ON ");
+     else
+         appendStringInfoString(buf, "ON ");
+
      /* The event the rule is fired for */
      switch (ev_type)
      {
***************
*** 1370,1375 ****
--- 1436,1443 ----
          deparse_context context;
          deparse_namespace dpns;

+         if (prettyFlags & PRETTYFLAG_INDENT)
+             appendStringInfoString(buf, "\n  ");
          appendStringInfo(buf, " WHERE ");

          qual = stringToNode(ev_qual);
***************
*** 1391,1396 ****
--- 1459,1466 ----
          context.buf = buf;
          context.namespaces = makeList1(&dpns);
          context.varprefix = (length(query->rtable) != 1);
+         context.prettyFlags = prettyFlags;
+         context.indentLevel = PRETTYINDENT_STD;
          dpns.rtable = query->rtable;
          dpns.outer_varno = dpns.inner_varno = 0;
          dpns.outer_rte = dpns.inner_rte = NULL;
***************
*** 1414,1421 ****
          foreach(action, actions)
          {
              query = (Query *) lfirst(action);
!             get_query_def(query, buf, NIL, NULL);
!             appendStringInfo(buf, "; ");
          }
          appendStringInfo(buf, ");");
      }
--- 1484,1494 ----
          foreach(action, actions)
          {
              query = (Query *) lfirst(action);
!             get_query_def(query, buf, NIL, NULL, prettyFlags, 0);
!             if (prettyFlags)
!                 appendStringInfo(buf, ";\n");
!             else
!                 appendStringInfo(buf, "; ");
          }
          appendStringInfo(buf, ");");
      }
***************
*** 1428,1434 ****
          Query       *query;

          query = (Query *) lfirst(actions);
!         get_query_def(query, buf, NIL, NULL);
          appendStringInfo(buf, ";");
      }
  }
--- 1501,1507 ----
          Query       *query;

          query = (Query *) lfirst(actions);
!         get_query_def(query, buf, NIL, NULL, prettyFlags, 0);
          appendStringInfo(buf, ";");
      }
  }
***************
*** 1440,1446 ****
   * ----------
   */
  static void
! make_viewdef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc)
  {
      Query       *query;
      char        ev_type;
--- 1513,1519 ----
   * ----------
   */
  static void
! make_viewdef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, int prettyFlags)
  {
      Query       *query;
      char        ev_type;
***************
*** 1494,1500 ****

      ev_relation = heap_open(ev_class, AccessShareLock);

!     get_query_def(query, buf, NIL, RelationGetDescr(ev_relation));
      appendStringInfo(buf, ";");

      heap_close(ev_relation, AccessShareLock);
--- 1567,1573 ----

      ev_relation = heap_open(ev_class, AccessShareLock);

!     get_query_def(query, buf, NIL, RelationGetDescr(ev_relation), prettyFlags, 0);
      appendStringInfo(buf, ";");

      heap_close(ev_relation, AccessShareLock);
***************
*** 1510,1516 ****
   */
  static void
  get_query_def(Query *query, StringInfo buf, List *parentnamespace,
!               TupleDesc resultDesc)
  {
      deparse_context context;
      deparse_namespace dpns;
--- 1583,1589 ----
   */
  static void
  get_query_def(Query *query, StringInfo buf, List *parentnamespace,
!               TupleDesc resultDesc, int prettyFlags, int startIndent)
  {
      deparse_context context;
      deparse_namespace dpns;
***************
*** 1519,1524 ****
--- 1592,1600 ----
      context.namespaces = lcons(&dpns, parentnamespace);
      context.varprefix = (parentnamespace != NIL ||
                           length(query->rtable) != 1);
+     context.prettyFlags = prettyFlags;
+     context.indentLevel = startIndent;
+
      dpns.rtable = query->rtable;
      dpns.outer_varno = dpns.inner_varno = 0;
      dpns.outer_rte = dpns.inner_rte = NULL;
***************
*** 1590,1596 ****
      /* Add the ORDER BY clause if given */
      if (query->sortClause != NIL)
      {
!         appendStringInfo(buf, " ORDER BY ");
          sep = "";
          foreach(l, query->sortClause)
          {
--- 1666,1672 ----
      /* Add the ORDER BY clause if given */
      if (query->sortClause != NIL)
      {
!             appendContextKeyword(context, " ORDER BY ", -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
          sep = "";
          foreach(l, query->sortClause)
          {
***************
*** 1619,1630 ****
      /* Add the LIMIT clause if given */
      if (query->limitOffset != NULL)
      {
!         appendStringInfo(buf, " OFFSET ");
          get_rule_expr(query->limitOffset, context, false);
      }
      if (query->limitCount != NULL)
      {
!         appendStringInfo(buf, " LIMIT ");
          if (IsA(query->limitCount, Const) &&
              ((Const *) query->limitCount)->constisnull)
              appendStringInfo(buf, "ALL");
--- 1695,1706 ----
      /* Add the LIMIT clause if given */
      if (query->limitOffset != NULL)
      {
!         appendContextKeyword(context, " OFFSET ", -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
          get_rule_expr(query->limitOffset, context, false);
      }
      if (query->limitCount != NULL)
      {
!         appendContextKeyword(context, " LIMIT ", -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
          if (IsA(query->limitCount, Const) &&
              ((Const *) query->limitCount)->constisnull)
              appendStringInfo(buf, "ALL");
***************
*** 1645,1650 ****
--- 1721,1731 ----
      /*
       * Build up the query string - first we say SELECT
       */
+     if (PRETTY_INDENT(context))
+     {
+         context->indentLevel += PRETTYINDENT_STD;
+         appendStringInfoChar(buf, ' ');
+     }
      appendStringInfo(buf, "SELECT");

      /* Add the DISTINCT clause if given */
***************
*** 1724,1737 ****
      /* Add the WHERE clause if given */
      if (query->jointree->quals != NULL)
      {
!         appendStringInfo(buf, " WHERE ");
          get_rule_expr(query->jointree->quals, context, false);
      }

      /* Add the GROUP BY clause if given */
      if (query->groupClause != NULL)
      {
!         appendStringInfo(buf, " GROUP BY ");
          sep = "";
          foreach(l, query->groupClause)
          {
--- 1805,1818 ----
      /* 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)
      {
!         appendContextKeyword(context, " GROUP BY ", -PRETTYINDENT_STD, PRETTYINDENT_STD, 1);
          sep = "";
          foreach(l, query->groupClause)
          {
***************
*** 1747,1753 ****
      /* Add the HAVING clause if given */
      if (query->havingQual != NULL)
      {
!         appendStringInfo(buf, " HAVING ");
          get_rule_expr(query->havingQual, context, false);
      }
  }
--- 1828,1834 ----
      /* 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);
      }
  }
***************
*** 1765,1799 ****
          Query       *subquery = rte->subquery;

          Assert(subquery != NULL);
!         get_query_def(subquery, buf, context->namespaces, resultDesc);
      }
      else if (IsA(setOp, SetOperationStmt))
      {
          SetOperationStmt *op = (SetOperationStmt *) setOp;

-         appendStringInfo(buf, "((");
          get_setop_query(op->larg, query, context, resultDesc);
          switch (op->op)
          {
              case SETOP_UNION:
!                 appendStringInfo(buf, ") UNION ");
                  break;
              case SETOP_INTERSECT:
!                 appendStringInfo(buf, ") INTERSECT ");
                  break;
              case SETOP_EXCEPT:
!                 appendStringInfo(buf, ") EXCEPT ");
                  break;
              default:
                  elog(ERROR, "unrecognized set op: %d",
                       (int) op->op);
          }
          if (op->all)
!             appendStringInfo(buf, "ALL (");
          else
!             appendStringInfo(buf, "(");
          get_setop_query(op->rarg, query, context, resultDesc);
!         appendStringInfo(buf, "))");
      }
      else
      {
--- 1846,1909 ----
          Query       *subquery = rte->subquery;

          Assert(subquery != NULL);
!         get_query_def(subquery, buf, context->namespaces, resultDesc, context->prettyFlags, context->indentLevel);
      }
      else if (IsA(setOp, SetOperationStmt))
      {
          SetOperationStmt *op = (SetOperationStmt *) setOp;
+         bool need_paren=(PRETTY_PAREN(context) ? !IsA(op->rarg, RangeTblRef) : true);
+
+         if (!PRETTY_PAREN(context))
+             appendStringInfoString(buf, "((");

          get_setop_query(op->larg, query, context, resultDesc);
+
+         if (!PRETTY_PAREN(context))
+             appendStringInfoChar(buf, ')');
+         if (!PRETTY_INDENT(context))
+             appendStringInfoChar(buf, ' ');
          switch (op->op)
          {
              case SETOP_UNION:
!                 appendContextKeyword(context, "UNION ", -PRETTYINDENT_STD, 0, 0);
                  break;
              case SETOP_INTERSECT:
!                 appendContextKeyword(context, "INTERSECT ", -PRETTYINDENT_STD, 0, 0);
                  break;
              case SETOP_EXCEPT:
!                 appendContextKeyword(context, "EXCEPT ", -PRETTYINDENT_STD, 0, 0);
                  break;
              default:
                  elog(ERROR, "unrecognized set op: %d",
                       (int) op->op);
          }
          if (op->all)
!             appendStringInfo(buf, "ALL ");
!
!         if (PRETTY_INDENT(context))
!             appendStringInfoChar(buf, '\n');
!
!         if (PRETTY_PAREN(context))
!         {
!             if (need_paren)
!             {
!             appendStringInfoChar(buf, '(');
!             if (PRETTY_INDENT(context))
!                 appendStringInfoChar(buf, '\n');
!             }
!         }
          else
!             appendStringInfoChar(buf, '(');
!
          get_setop_query(op->rarg, query, context, resultDesc);
!
!         if (PRETTY_PAREN(context))
!         {
!             if (need_paren)
!             appendStringInfoChar(buf, ')');
!         }
!         else
!             appendStringInfoString(buf, "))");
      }
      else
      {
***************
*** 1866,1871 ****
--- 1976,1987 ----
       */
      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));

***************
*** 1887,1893 ****
      /* Add the VALUES or the SELECT */
      if (select_rte == NULL)
      {
!         appendStringInfo(buf, "VALUES (");
          sep = "";
          foreach(l, query->targetList)
          {
--- 2003,2009 ----
      /* Add the VALUES or the SELECT */
      if (select_rte == NULL)
      {
!         appendContextKeyword(context, "VALUES (", -PRETTYINDENT_STD, PRETTYINDENT_STD, 2);
          sep = "";
          foreach(l, query->targetList)
          {
***************
*** 1903,1909 ****
          appendStringInfoChar(buf, ')');
      }
      else
!         get_query_def(select_rte->subquery, buf, NIL, NULL);
  }


--- 2019,2025 ----
          appendStringInfoChar(buf, ')');
      }
      else
!         get_query_def(select_rte->subquery, buf, NIL, NULL, context->prettyFlags, context->indentLevel);
  }


***************
*** 1924,1929 ****
--- 2040,2050 ----
       */
      rte = rt_fetch(query->resultRelation, query->rtable);
      Assert(rte->rtekind == RTE_RELATION);
+     if (PRETTY_INDENT(context))
+     {
+         appendStringInfoChar(buf, ' ');
+         context->indentLevel += PRETTYINDENT_STD;
+     }
      appendStringInfo(buf, "UPDATE %s%s SET ",
                       only_marker(rte),
                       generate_relation_name(rte->relid));
***************
*** 1957,1963 ****
      /* Finally add a WHERE clause if given */
      if (query->jointree->quals != NULL)
      {
!         appendStringInfo(buf, " WHERE ");
          get_rule_expr(query->jointree->quals, context, false);
      }
  }
--- 2078,2084 ----
      /* Finally 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);
      }
  }
***************
*** 1978,1983 ****
--- 2099,2109 ----
       */
      rte = rt_fetch(query->resultRelation, query->rtable);
      Assert(rte->rtekind == RTE_RELATION);
+     if (PRETTY_INDENT(context))
+     {
+         context->indentLevel += PRETTYINDENT_STD;
+         appendStringInfoChar(buf, ' ');
+     }
      appendStringInfo(buf, "DELETE FROM %s%s",
                       only_marker(rte),
                       generate_relation_name(rte->relid));
***************
*** 1985,1991 ****
      /* Add a WHERE clause if given */
      if (query->jointree->quals != NULL)
      {
!         appendStringInfo(buf, " WHERE ");
          get_rule_expr(query->jointree->quals, context, false);
      }
  }
--- 2111,2117 ----
      /* 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);
      }
  }
***************
*** 2004,2009 ****
--- 2130,2136 ----
      {
          NotifyStmt *stmt = (NotifyStmt *) query->utilityStmt;

+         appendContextKeyword(context, "", 0, PRETTYINDENT_STD, 1);
          appendStringInfo(buf, "NOTIFY %s",
                     quote_qualified_identifier(stmt->relation->schemaname,
                                                stmt->relation->relname));
***************
*** 2145,2150 ****
--- 2272,2513 ----
  }


+ /********************************************
+  * get_simple_binary_op_name
+  * helper function for isSimpleNode
+  * will return single char binary operator
+  *******************************************/
+
+ static char *get_simple_binary_op_name(OpExpr *expr)
+ {
+     List       *args = expr->args;
+
+     if (length(args) == 2)
+     {
+         /* binary operator */
+         Node       *arg1 = (Node *) lfirst(args);
+         Node       *arg2 = (Node *) lsecond(args);
+         char *op = generate_operator_name(expr->opno, exprType(arg1), exprType(arg2));
+
+         if (strlen(op) == 1)
+             return op;
+     }
+     return 0;
+ }
+
+
+ /***************************************
+  * check if given node is simple.
+  *  false  : not simple
+  *  true   : simple in the context of parent node's type
+  ***************************************/
+
+ static bool isSimpleNode(Node *node, Node *parentNode, int prettyFlags)
+ {
+     if (!node)
+     return true;
+
+     switch (nodeTag(node))
+     {
+     // single words: always simple
+     case T_Var:
+     case T_Const:
+     case T_Param:
+
+     // function-like: name(..) or name[..]
+     case T_ArrayRef:
+     case T_ArrayExpr:
+     case T_CoalesceExpr:
+     case T_NullIfExpr:
+     case T_Aggref:
+     case T_FuncExpr:
+
+         // CASE keywords act as parentheses
+     case T_CaseExpr:
+         return true;
+
+         // appears simple since . has top precedence, unless parent is T_FieldSelect itself!
+     case T_FieldSelect:
+         return (nodeTag(parentNode) == T_FieldSelect ? false : true);
+
+
+         // maybe simple, check args
+     case T_CoerceToDomain:
+         return isSimpleNode((Node*) ((CoerceToDomain*)node)->arg, node, prettyFlags);
+     case T_RelabelType:
+         return isSimpleNode((Node*) ((RelabelType*)node)->arg, node, prettyFlags);
+
+
+     // depends on parent node type; needs further checking
+     case T_OpExpr:
+     {
+         if (prettyFlags & PRETTYFLAG_PAREN && nodeTag(parentNode) == T_OpExpr)
+         {
+         char *op=get_simple_binary_op_name((OpExpr*)node);
+         char *parentOp=get_simple_binary_op_name((OpExpr*)parentNode);
+         if (!op || !parentOp)
+             return false;
+
+                 // we know only these basic operators
+         if (!strchr("+-*/%", *op) || !strchr("+-*/%", *parentOp))
+             return false;
+
+         // natural operator precedence, so we don't need parentheses
+         if (strchr("*/%", *op) || strchr("+-", *parentOp))
+             return true;
+
+         return false;
+         }
+             // else do the same stuff as for T_SubLink et al.
+     }
+     case T_SubLink:
+     case T_NullTest:
+     case T_BooleanTest:
+     case T_DistinctExpr:
+     {
+         switch (nodeTag(parentNode))
+         {
+         case T_FuncExpr:
+         {
+             // special handling for casts
+             CoercionForm type=((FuncExpr*)parentNode)->funcformat;
+             if (type == COERCE_EXPLICIT_CAST ||    type == COERCE_IMPLICIT_CAST)
+             return false;
+                     return true;      // own parentheses
+         }
+         case T_BoolExpr:      // lower precedence
+         case T_ArrayRef:      // other separators
+         case T_ArrayExpr:     // other separators
+         case T_CoalesceExpr:  // own parentheses
+         case T_NullIfExpr:    // other separators
+         case T_Aggref:        // own parentheses
+         case T_CaseExpr:      // other separators
+             return true;
+         default:
+             return false;
+         }
+     }
+     case T_BoolExpr:
+         switch (nodeTag(parentNode))
+         {
+         case T_BoolExpr:
+             if (prettyFlags & PRETTYFLAG_PAREN)
+             {
+             BoolExprType type=((BoolExpr*)node)->boolop;
+             BoolExprType parentType=((BoolExpr*)parentNode)->boolop;
+             switch (type)
+             {
+                 case NOT_EXPR:
+                 case AND_EXPR:
+                 if (parentType == AND_EXPR || parentType == OR_EXPR)
+                     return true;
+                 break;
+                 case OR_EXPR:
+                 if (parentType == OR_EXPR)
+                     return true;
+                 break;
+             }
+             }
+             return false;
+         case T_FuncExpr:
+         {
+             // special handling for casts
+             CoercionForm type=((FuncExpr*)parentNode)->funcformat;
+             if (type == COERCE_EXPLICIT_CAST ||    type == COERCE_IMPLICIT_CAST)
+             return false;
+                     return true;      // own parentheses
+         }
+         case T_ArrayRef:      // other separators
+         case T_ArrayExpr:     // other separators
+         case T_CoalesceExpr:  // own parentheses
+         case T_NullIfExpr:    // other separators
+         case T_Aggref:        // own parentheses
+         case T_CaseExpr:      // other separators
+             return true;
+         default:
+             return false;
+         }
+         // these are not completely implemented; so far, they're simple
+     case T_SubPlan:
+     case T_CoerceToDomainValue:
+         return true;
+
+     case T_ScalarArrayOpExpr:
+         // need to check
+     default:
+         break;
+     }
+     // those we don't know: in dubio complexo
+     return false;
+ }
+
+
+ /******************************************
+  * appendContextKeyword
+  * append spaces to buffer
+  ******************************************/
+ static void appendStringInfoSpace(StringInfo buf, int count)
+ {
+     while (count-- > 0)
+     appendStringInfoChar(buf, ' ');
+ }
+
+ /******************************************
+  * appendContextKeyword
+  * performing a line break, and indentation
+  * if prettyPrint is enabled.
+  * Otherwise, only the keyword is appended
+  *****************************************/
+
+ static void appendContextKeyword(deparse_context *context, char *str, int indentBefore, int indentAfter, int
indentPlus)
+ {
+     if (PRETTY_INDENT(context))
+     {
+     context->indentLevel += indentBefore;
+     if (context->indentLevel < 0)
+         context->indentLevel=0;
+
+     appendStringInfoChar(context->buf, '\n');
+     appendStringInfoSpace(context->buf, context->indentLevel + indentPlus);
+     }
+
+     appendStringInfoString(context->buf, str);
+
+     if (PRETTY_INDENT(context))
+     {
+     context->indentLevel += indentAfter;
+     if (context->indentLevel < 0)
+         context->indentLevel=0;
+     }
+ }
+
+
+ /*
+  * get_rule_expr_paren  - parsing expr using get_rule_expr,
+  * embracing the string with parentheses if necessary for prettyPrint.
+  * never embracing if prettyFlags=0, because it's done in the calling node.
+  *
+  * Any node that does *not* embrace its argument node by sql syntax (with parentheses, non-operator keywords
+  * like CASE/WHEN/ON, or comma etc) should use get_rule_expr_paren instead of get_rule_expr
+  * so parentheses can be added.
+  */
+
+ static void
+ get_rule_expr_paren(Node *node, deparse_context *context,
+             bool showimplicit, Node *parentNode)
+ {
+     bool need_paren = PRETTY_PAREN(context) && !isSimpleNode(node, parentNode, context->prettyFlags);
+
+     if (need_paren)
+         appendStringInfoChar(context->buf, '(');
+
+     get_rule_expr(node, context, showimplicit);
+
+     if (need_paren)
+         appendStringInfoChar(context->buf, ')');
+ }
+
+
  /* ----------
   * get_rule_expr            - Parse back an expression
   *
***************
*** 2299,2310 ****
                  List       *args = expr->args;
                  Node       *arg1 = (Node *) lfirst(args);
                  Node       *arg2 = (Node *) lsecond(args);
!
!                 appendStringInfoChar(buf, '(');
!                 get_rule_expr(arg1, context, true);
                  appendStringInfo(buf, " IS DISTINCT FROM ");
!                 get_rule_expr(arg2, context, true);
!                 appendStringInfoChar(buf, ')');
              }
              break;

--- 2662,2674 ----
                  List       *args = expr->args;
                  Node       *arg1 = (Node *) lfirst(args);
                  Node       *arg2 = (Node *) lsecond(args);
!                 if (!PRETTY_PAREN(context))
!                     appendStringInfoChar(buf, '(');
!                 get_rule_expr_paren(arg1, context, true, node);
                  appendStringInfo(buf, " IS DISTINCT FROM ");
!                 get_rule_expr_paren(arg2, context, true, node);
!                 if (!PRETTY_PAREN(context))
!                     appendStringInfoChar(buf, ')');
              }
              break;

***************
*** 2315,2329 ****
                  Node       *arg1 = (Node *) lfirst(args);
                  Node       *arg2 = (Node *) lsecond(args);

!                 appendStringInfoChar(buf, '(');
!                 get_rule_expr(arg1, context, true);
                  appendStringInfo(buf, " %s %s (",
                                   generate_operator_name(expr->opno,
                                                          exprType(arg1),
                                          get_element_type(exprType(arg2))),
                                   expr->useOr ? "ANY" : "ALL");
!                 get_rule_expr(arg2, context, true);
!                 appendStringInfo(buf, "))");
              }
              break;

--- 2679,2697 ----
                  Node       *arg1 = (Node *) lfirst(args);
                  Node       *arg2 = (Node *) lsecond(args);

!                 if (!PRETTY_PAREN(context))
!                     appendStringInfoChar(buf, '(');
!                 get_rule_expr_paren(arg1, context, true, node);
                  appendStringInfo(buf, " %s %s (",
                                   generate_operator_name(expr->opno,
                                                          exprType(arg1),
                                          get_element_type(exprType(arg2))),
                                   expr->useOr ? "ANY" : "ALL");
!                 get_rule_expr_paren(arg2, context, true, node);
!                 appendStringInfoString(buf, ")");
!
!                 if (!PRETTY_PAREN(context))
!                     appendStringInfoChar(buf, ')');
              }
              break;

***************
*** 2335,2367 ****
                  switch (expr->boolop)
                  {
                      case AND_EXPR:
!                         appendStringInfoChar(buf, '(');
!                         get_rule_expr((Node *) lfirst(args), context, false);
                          while ((args = lnext(args)) != NIL)
                          {
                              appendStringInfo(buf, " AND ");
!                             get_rule_expr((Node *) lfirst(args), context,
!                                           false);
                          }
!                         appendStringInfoChar(buf, ')');
                          break;

                      case OR_EXPR:
!                         appendStringInfoChar(buf, '(');
!                         get_rule_expr((Node *) lfirst(args), context, false);
                          while ((args = lnext(args)) != NIL)
                          {
                              appendStringInfo(buf, " OR ");
!                             get_rule_expr((Node *) lfirst(args), context,
!                                           false);
                          }
!                         appendStringInfoChar(buf, ')');
                          break;

                      case NOT_EXPR:
!                         appendStringInfo(buf, "(NOT ");
!                         get_rule_expr((Node *) lfirst(args), context, false);
!                         appendStringInfoChar(buf, ')');
                          break;

                      default:
--- 2703,2742 ----
                  switch (expr->boolop)
                  {
                      case AND_EXPR:
!                             if (!PRETTY_PAREN(context))
!                             appendStringInfoChar(buf, '(');
!                         get_rule_expr_paren((Node *) lfirst(args), context, false, node);
                          while ((args = lnext(args)) != NIL)
                          {
                              appendStringInfo(buf, " AND ");
!                             get_rule_expr_paren((Node *) lfirst(args), context,
!                                           false, node);
                          }
!                             if (!PRETTY_PAREN(context))
!                             appendStringInfoChar(buf, ')');
                          break;

                      case OR_EXPR:
!                             if (!PRETTY_PAREN(context))
!                             appendStringInfoChar(buf, '(');
!                         get_rule_expr_paren((Node *) lfirst(args), context, false, node);
                          while ((args = lnext(args)) != NIL)
                          {
                              appendStringInfo(buf, " OR ");
!                             get_rule_expr_paren((Node *) lfirst(args), context,
!                                           false, node);
                          }
!                             if (!PRETTY_PAREN(context))
!                             appendStringInfoChar(buf, ')');
                          break;

                      case NOT_EXPR:
!                             if (!PRETTY_PAREN(context))
!                             appendStringInfoChar(buf, '(');
!                         appendStringInfo(buf, "NOT ");
!                         get_rule_expr_paren((Node *) lfirst(args), context, false, node);
!                             if (!PRETTY_PAREN(context))
!                             appendStringInfoChar(buf, ')');
                          break;

                      default:
***************
*** 2409,2417 ****
                   * arg.fieldname, but most cases where FieldSelect is used
                   * are *not* simple.  So, always use parenthesized syntax.
                   */
!                 appendStringInfoChar(buf, '(');
!                 get_rule_expr((Node *) fselect->arg, context, true);
!                 appendStringInfo(buf, ").%s", quote_identifier(fieldname));
              }
              break;

--- 2784,2795 ----
                   * arg.fieldname, but most cases where FieldSelect is used
                   * are *not* simple.  So, always use parenthesized syntax.
                   */
!                     if (!PRETTY_PAREN(context))
!                     appendStringInfoChar(buf, '(');
!                 get_rule_expr_paren((Node *) fselect->arg, context, true, node);
!                     if (!PRETTY_PAREN(context))
!                     appendStringInfoChar(buf, ')');
!                 appendStringInfo(buf, ".%s", quote_identifier(fieldname));
              }
              break;

***************
*** 2424,2430 ****
                      !showimplicit)
                  {
                      /* don't show the implicit cast */
!                     get_rule_expr(arg, context, showimplicit);
                  }
                  else
                  {
--- 2802,2808 ----
                      !showimplicit)
                  {
                      /* don't show the implicit cast */
!                     get_rule_expr_paren(arg, context, showimplicit, node);
                  }
                  else
                  {
***************
*** 2436,2444 ****
                       */
                      arg = strip_type_coercion(arg, relabel->resulttype);

!                     appendStringInfoChar(buf, '(');
!                     get_rule_expr(arg, context, showimplicit);
!                     appendStringInfo(buf, ")::%s",
                              format_type_with_typemod(relabel->resulttype,
                                                       relabel->resulttypmod));
                  }
--- 2814,2826 ----
                       */
                      arg = strip_type_coercion(arg, relabel->resulttype);

!                     if (!PRETTY_PAREN(context))
!                         appendStringInfoChar(buf, '(');
!
!                     get_rule_expr_paren(arg, context, showimplicit, node);
!                     if (!PRETTY_PAREN(context))
!                         appendStringInfoChar(buf, ')');
!                     appendStringInfo(buf, "::%s",
                              format_type_with_typemod(relabel->resulttype,
                                                       relabel->resulttypmod));
                  }
***************
*** 2450,2468 ****
                  CaseExpr   *caseexpr = (CaseExpr *) node;
                  List       *temp;

!                 appendStringInfo(buf, "CASE");
                  foreach(temp, caseexpr->args)
                  {
                      CaseWhen   *when = (CaseWhen *) lfirst(temp);

!                     appendStringInfo(buf, " WHEN ");
                      get_rule_expr((Node *) when->expr, context, false);
                      appendStringInfo(buf, " THEN ");
                      get_rule_expr((Node *) when->result, context, true);
                  }
!                 appendStringInfo(buf, " ELSE ");
                  get_rule_expr((Node *) caseexpr->defresult, context, true);
!                 appendStringInfo(buf, " END");
              }
              break;

--- 2832,2858 ----
                  CaseExpr   *caseexpr = (CaseExpr *) node;
                  List       *temp;

!                 appendContextKeyword(context, "CASE", 0, PRETTYINDENT_VAR, 0);
                  foreach(temp, caseexpr->args)
                  {
                      CaseWhen   *when = (CaseWhen *) lfirst(temp);

!                     if (!PRETTY_INDENT(context))
!                         appendStringInfoChar(buf, ' ');
!
!                     appendContextKeyword(context, "WHEN ", 0, 0, 0);
                      get_rule_expr((Node *) when->expr, context, false);
+
                      appendStringInfo(buf, " THEN ");
                      get_rule_expr((Node *) when->result, context, true);
                  }
!                 if (!PRETTY_INDENT(context))
!                     appendStringInfoChar(buf, ' ');
!                 appendContextKeyword(context, "ELSE ", 0, 0, 0);
                  get_rule_expr((Node *) caseexpr->defresult, context, true);
!                 if (!PRETTY_INDENT(context))
!                     appendStringInfoChar(buf, ' ');
!                 appendContextKeyword(context, "END", -PRETTYINDENT_VAR, 0, 0);
              }
              break;

***************
*** 2530,2549 ****
              {
                  NullTest   *ntest = (NullTest *) node;

!                 appendStringInfo(buf, "(");
!                 get_rule_expr((Node *) ntest->arg, context, true);
                  switch (ntest->nulltesttype)
                  {
                      case IS_NULL:
!                         appendStringInfo(buf, " IS NULL)");
                          break;
                      case IS_NOT_NULL:
!                         appendStringInfo(buf, " IS NOT NULL)");
                          break;
                      default:
                          elog(ERROR, "unrecognized nulltesttype: %d",
                               (int) ntest->nulltesttype);
                  }
              }
              break;

--- 2920,2942 ----
              {
                  NullTest   *ntest = (NullTest *) node;

!                 if (!PRETTY_PAREN(context))
!                     appendStringInfoChar(buf, '(');
!                 get_rule_expr_paren((Node *) ntest->arg, context, true, node);
                  switch (ntest->nulltesttype)
                  {
                      case IS_NULL:
!                         appendStringInfo(buf, " IS NULL");
                          break;
                      case IS_NOT_NULL:
!                         appendStringInfo(buf, " IS NOT NULL");
                          break;
                      default:
                          elog(ERROR, "unrecognized nulltesttype: %d",
                               (int) ntest->nulltesttype);
                  }
+                 if (!PRETTY_PAREN(context))
+                     appendStringInfoChar(buf, ')');
              }
              break;

***************
*** 2551,2582 ****
              {
                  BooleanTest *btest = (BooleanTest *) node;

!                 appendStringInfo(buf, "(");
!                 get_rule_expr((Node *) btest->arg, context, false);
                  switch (btest->booltesttype)
                  {
                      case IS_TRUE:
!                         appendStringInfo(buf, " IS TRUE)");
                          break;
                      case IS_NOT_TRUE:
!                         appendStringInfo(buf, " IS NOT TRUE)");
                          break;
                      case IS_FALSE:
!                         appendStringInfo(buf, " IS FALSE)");
                          break;
                      case IS_NOT_FALSE:
!                         appendStringInfo(buf, " IS NOT FALSE)");
                          break;
                      case IS_UNKNOWN:
!                         appendStringInfo(buf, " IS UNKNOWN)");
                          break;
                      case IS_NOT_UNKNOWN:
!                         appendStringInfo(buf, " IS NOT UNKNOWN)");
                          break;
                      default:
                          elog(ERROR, "unrecognized booltesttype: %d",
                               (int) btest->booltesttype);
                  }
              }
              break;

--- 2944,2978 ----
              {
                  BooleanTest *btest = (BooleanTest *) node;

!                 if (!PRETTY_PAREN(context))
!                     appendStringInfoChar(buf, '(');
!                 get_rule_expr_paren((Node *) btest->arg, context, false, node);
                  switch (btest->booltesttype)
                  {
                      case IS_TRUE:
!                         appendStringInfo(buf, " IS TRUE");
                          break;
                      case IS_NOT_TRUE:
!                         appendStringInfo(buf, " IS NOT TRUE");
                          break;
                      case IS_FALSE:
!                         appendStringInfo(buf, " IS FALSE");
                          break;
                      case IS_NOT_FALSE:
!                         appendStringInfo(buf, " IS NOT FALSE");
                          break;
                      case IS_UNKNOWN:
!                         appendStringInfo(buf, " IS UNKNOWN");
                          break;
                      case IS_NOT_UNKNOWN:
!                         appendStringInfo(buf, " IS NOT UNKNOWN");
                          break;
                      default:
                          elog(ERROR, "unrecognized booltesttype: %d",
                               (int) btest->booltesttype);
                  }
+                 if (!PRETTY_PAREN(context))
+                     appendStringInfoChar(buf, ')');
              }
              break;

***************
*** 2598,2606 ****
                  }
                  else
                  {
!                     appendStringInfoChar(buf, '(');
!                     get_rule_expr(arg, context, false);
!                     appendStringInfo(buf, ")::%s",
                              format_type_with_typemod(ctest->resulttype,
                                                       ctest->resulttypmod));
                  }
--- 2994,3007 ----
                  }
                  else
                  {
!                     if (!PRETTY_PAREN(context))
!                         appendStringInfoChar(buf, '(');
!
!                     get_rule_expr_paren(arg, context, false, node);
!
!                     if (!PRETTY_PAREN(context))
!                         appendStringInfoChar(buf, ')');
!                     appendStringInfo(buf, "::%s",
                              format_type_with_typemod(ctest->resulttype,
                                                       ctest->resulttypmod));
                  }
***************
*** 2632,2650 ****
      Oid            opno = expr->opno;
      List       *args = expr->args;

!     appendStringInfoChar(buf, '(');
      if (length(args) == 2)
      {
          /* binary operator */
          Node       *arg1 = (Node *) lfirst(args);
          Node       *arg2 = (Node *) lsecond(args);
!
!         get_rule_expr(arg1, context, true);
          appendStringInfo(buf, " %s ",
                           generate_operator_name(opno,
                                                  exprType(arg1),
                                                  exprType(arg2)));
!         get_rule_expr(arg2, context, true);
      }
      else
      {
--- 3033,3051 ----
      Oid            opno = expr->opno;
      List       *args = expr->args;

!     if (!PRETTY_PAREN(context))
!         appendStringInfoChar(buf, '(');
      if (length(args) == 2)
      {
          /* binary operator */
          Node       *arg1 = (Node *) lfirst(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
      {
***************
*** 2666,2675 ****
                                   generate_operator_name(opno,
                                                          InvalidOid,
                                                          exprType(arg)));
!                 get_rule_expr(arg, context, true);
                  break;
              case 'r':
!                 get_rule_expr(arg, context, true);
                  appendStringInfo(buf, " %s",
                                   generate_operator_name(opno,
                                                          exprType(arg),
--- 3067,3076 ----
                                   generate_operator_name(opno,
                                                          InvalidOid,
                                                          exprType(arg)));
!                 get_rule_expr_paren(arg, context, true, (Node*)expr);
                  break;
              case 'r':
!                 get_rule_expr_paren(arg, context, true, (Node*)expr);
                  appendStringInfo(buf, " %s",
                                   generate_operator_name(opno,
                                                          exprType(arg),
***************
*** 2680,2686 ****
          }
          ReleaseSysCache(tp);
      }
!     appendStringInfoChar(buf, ')');
  }

  /*
--- 3081,3088 ----
          }
          ReleaseSysCache(tp);
      }
!     if (!PRETTY_PAREN(context))
!         appendStringInfoChar(buf, ')');
  }

  /*
***************
*** 2703,2709 ****
       */
      if (expr->funcformat == COERCE_IMPLICIT_CAST && !showimplicit)
      {
!         get_rule_expr((Node *) lfirst(expr->args), context, showimplicit);
          return;
      }

--- 3105,3111 ----
       */
      if (expr->funcformat == COERCE_IMPLICIT_CAST && !showimplicit)
      {
!         get_rule_expr_paren((Node *) lfirst(expr->args), context, showimplicit, (Node*)expr);
          return;
      }

***************
*** 2729,2737 ****
           */
          arg = strip_type_coercion(arg, rettype);

!         appendStringInfoChar(buf, '(');
!         get_rule_expr(arg, context, showimplicit);
!         appendStringInfo(buf, ")::%s",
                           format_type_with_typemod(rettype, coercedTypmod));

          return;
--- 3131,3144 ----
           */
          arg = strip_type_coercion(arg, rettype);

!         if (!PRETTY_PAREN(context))
!             appendStringInfoChar(buf, '(');
!
!         get_rule_expr_paren(arg, context, showimplicit, (Node*)expr);
!
!         if (!PRETTY_PAREN(context))
!             appendStringInfoChar(buf, ')');
!         appendStringInfo(buf, "::%s",
                           format_type_with_typemod(rettype, coercedTypmod));

          return;
***************
*** 3052,3058 ****
      if (need_paren)
          appendStringInfoChar(buf, '(');

!     get_query_def(query, buf, context->namespaces, NULL);

      if (need_paren)
          appendStringInfo(buf, "))");
--- 3459,3465 ----
      if (need_paren)
          appendStringInfoChar(buf, '(');

!     get_query_def(query, buf, context->namespaces, NULL, context->prettyFlags, context->indentLevel);

      if (need_paren)
          appendStringInfo(buf, "))");
***************
*** 3069,3075 ****
  get_from_clause(Query *query, deparse_context *context)
  {
      StringInfo    buf = context->buf;
!     char       *sep;
      List       *l;

      /*
--- 3476,3482 ----
  get_from_clause(Query *query, deparse_context *context)
  {
      StringInfo    buf = context->buf;
!     char       *sep=0;
      List       *l;

      /*
***************
*** 3079,3085 ****
       * sufficient to check here.) Also ignore the rule pseudo-RTEs for NEW
       * and OLD.
       */
-     sep = " FROM ";

      foreach(l, query->jointree->fromlist)
      {
--- 3486,3491 ----
***************
*** 3098,3104 ****
                  continue;
          }

!         appendStringInfo(buf, sep);
          get_from_clause_item(jtnode, query, context);
          sep = ", ";
      }
--- 3504,3514 ----
                  continue;
          }

!         if (!sep)
!             appendContextKeyword(context, " FROM ", -PRETTYINDENT_STD, PRETTYINDENT_STD, 2);
!         else
!             appendStringInfo(buf, sep);
!
          get_from_clause_item(jtnode, query, context);
          sep = ", ";
      }
***************
*** 3127,3133 ****
              case RTE_SUBQUERY:
                  /* Subquery RTE */
                  appendStringInfoChar(buf, '(');
!                 get_query_def(rte->subquery, buf, context->namespaces, NULL);
                  appendStringInfoChar(buf, ')');
                  break;
              case RTE_FUNCTION:
--- 3537,3544 ----
              case RTE_SUBQUERY:
                  /* Subquery RTE */
                  appendStringInfoChar(buf, '(');
!                 get_query_def(rte->subquery, buf, context->namespaces, NULL,
!                           context->prettyFlags, context->indentLevel);
                  appendStringInfoChar(buf, ')');
                  break;
              case RTE_FUNCTION:
***************
*** 3149,3155 ****
              {
                  List       *col;

!                 appendStringInfo(buf, "(");
                  foreach(col, rte->alias->colnames)
                  {
                      if (col != rte->alias->colnames)
--- 3560,3566 ----
              {
                  List       *col;

!                 appendStringInfoChar(buf, '(');
                  foreach(col, rte->alias->colnames)
                  {
                      if (col != rte->alias->colnames)
***************
*** 3183,3218 ****
      else if (IsA(jtnode, JoinExpr))
      {
          JoinExpr   *j = (JoinExpr *) jtnode;

-         appendStringInfoChar(buf, '(');
          get_from_clause_item(j->larg, query, context);
          if (j->isNatural)
-             appendStringInfo(buf, " NATURAL");
-         switch (j->jointype)
          {
              case JOIN_INNER:
                  if (j->quals)
!                     appendStringInfo(buf, " JOIN ");
                  else
!                     appendStringInfo(buf, " CROSS JOIN ");
                  break;
              case JOIN_LEFT:
!                 appendStringInfo(buf, " LEFT JOIN ");
                  break;
              case JOIN_FULL:
!                 appendStringInfo(buf, " FULL JOIN ");
                  break;
              case JOIN_RIGHT:
!                 appendStringInfo(buf, " RIGHT JOIN ");
                  break;
              case JOIN_UNION:
!                 appendStringInfo(buf, " UNION JOIN ");
                  break;
              default:
                  elog(ERROR, "unrecognized join type: %d",
                       (int) j->jointype);
          }
          get_from_clause_item(j->rarg, query, context);
          if (!j->isNatural)
          {
              if (j->using)
--- 3594,3671 ----
      else if (IsA(jtnode, JoinExpr))
      {
          JoinExpr   *j = (JoinExpr *) jtnode;
+         bool need_paren_on_right = PRETTY_PAREN(context) && !IsA(j->rarg, RangeTblRef);
+
+         if (!PRETTY_PAREN(context) || j->alias != NULL)
+             appendStringInfoChar(buf, '(');

          get_from_clause_item(j->larg, query, context);
+
          if (j->isNatural)
          {
+             if (!PRETTY_INDENT(context))
+             appendStringInfoChar(buf, ' ');
+             switch (j->jointype)
+             {
              case JOIN_INNER:
                  if (j->quals)
!                     appendContextKeyword(context, "NATURAL JOIN ", -PRETTYINDENT_JOIN, PRETTYINDENT_JOIN, 0);
                  else
!                     appendContextKeyword(context, "NATURAL CROSS JOIN ", -PRETTYINDENT_JOIN, PRETTYINDENT_JOIN, 0);
                  break;
              case JOIN_LEFT:
!                 appendContextKeyword(context, "NATURAL LEFT JOIN ", -PRETTYINDENT_JOIN, PRETTYINDENT_JOIN, 0);
                  break;
              case JOIN_FULL:
!                 appendContextKeyword(context, "NATURAL FULL JOIN ", -PRETTYINDENT_JOIN, PRETTYINDENT_JOIN, 0);
                  break;
              case JOIN_RIGHT:
!                 appendContextKeyword(context, "NATURAL RIGHT JOIN ", -PRETTYINDENT_JOIN, PRETTYINDENT_JOIN, 0);
                  break;
              case JOIN_UNION:
!                 appendContextKeyword(context, "NATURAL UNION JOIN ", -PRETTYINDENT_JOIN, PRETTYINDENT_JOIN, 0);
                  break;
              default:
                  elog(ERROR, "unrecognized join type: %d",
                       (int) j->jointype);
+             }
+         }
+         else
+         {
+             switch (j->jointype)
+             {
+             case JOIN_INNER:
+                 if (j->quals)
+                     appendContextKeyword(context, " JOIN ", -PRETTYINDENT_JOIN, PRETTYINDENT_JOIN, 2);
+                 else
+                     appendContextKeyword(context, " CROSS JOIN ", -PRETTYINDENT_JOIN, PRETTYINDENT_JOIN, 1);
+                 break;
+             case JOIN_LEFT:
+                 appendContextKeyword(context, " LEFT JOIN ", -PRETTYINDENT_JOIN, PRETTYINDENT_JOIN, 2);
+                 break;
+             case JOIN_FULL:
+                 appendContextKeyword(context, " FULL JOIN ", -PRETTYINDENT_JOIN, PRETTYINDENT_JOIN, 2);
+                 break;
+             case JOIN_RIGHT:
+                 appendContextKeyword(context, " RIGHT JOIN ", -PRETTYINDENT_JOIN, PRETTYINDENT_JOIN, 2);
+                 break;
+             case JOIN_UNION:
+                 appendContextKeyword(context, " UNION JOIN ", -PRETTYINDENT_JOIN, PRETTYINDENT_JOIN, 2);
+                 break;
+             default:
+                 elog(ERROR, "get_from_clause_item: unknown 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, ')');
+
+             context->indentLevel -= PRETTYINDENT_JOIN_ON;
+
          if (!j->isNatural)
          {
              if (j->using)
***************
*** 3231,3242 ****
              }
              else if (j->quals)
              {
!                 appendStringInfo(buf, " ON (");
                  get_rule_expr(j->quals, context, false);
!                 appendStringInfoChar(buf, ')');
              }
          }
!         appendStringInfoChar(buf, ')');
          /* Yes, it's correct to put alias after the right paren ... */
          if (j->alias != NULL)
          {
--- 3684,3700 ----
              }
              else if (j->quals)
              {
!                 appendStringInfo(buf, " ON ");
!                 if (!PRETTY_PAREN(context))
!                     appendStringInfoChar(buf, '(');
                  get_rule_expr(j->quals, context, false);
!                 if (!PRETTY_PAREN(context))
!                     appendStringInfoChar(buf, ')');
              }
          }
!         if (!PRETTY_PAREN(context) || j->alias != NULL)
!             appendStringInfoChar(buf, ')');
!
          /* Yes, it's correct to put alias after the right paren ... */
          if (j->alias != NULL)
          {
***************
*** 3246,3252 ****
              {
                  List       *col;

!                 appendStringInfo(buf, "(");
                  foreach(col, j->alias->colnames)
                  {
                      if (col != j->alias->colnames)
--- 3704,3710 ----
              {
                  List       *col;

!                 appendStringInfoChar(buf, '(');
                  foreach(col, j->alias->colnames)
                  {
                      if (col != j->alias->colnames)
Index: src/include/catalog/pg_proc.h
===================================================================
RCS file: /cvsroot/pgsql-server/src/include/catalog/pg_proc.h,v
retrieving revision 1.309
diff -c -c -r1.309 pg_proc.h
*** src/include/catalog/pg_proc.h    1 Jul 2003 00:04:38 -0000    1.309
--- src/include/catalog/pg_proc.h    27 Jul 2003 05:38:45 -0000
***************
*** 3405,3410 ****
--- 3405,3424 ----
  DATA(insert OID = 2503 (  anyarray_send           PGNSP PGUID 12 f f t f s 1 17 "2277"  anyarray_send - _null_ ));
  DESCR("I/O");

+ /* System-view support functions with pretty-print option */
+ DATA(insert OID = 2504 (  pg_get_ruledef       PGNSP PGUID 12 f f t f s 2 25 "26 16"  pg_get_ruledef - _null_ ));
+ DESCR("source text of a rule with pretty-print option");
+ DATA(insert OID = 2505 (  pg_get_viewdef       PGNSP PGUID 12 f f t f s 2 25 "25 16"  pg_get_viewdef_name - _null_
));
+ DESCR("select statement of a view with pretty-print option");
+ DATA(insert OID = 2506 (  pg_get_viewdef       PGNSP PGUID 12 f f t f s 2 25 "26 16"  pg_get_viewdef - _null_ ));
+ DESCR("select statement of a view with pretty-print option");
+ DATA(insert OID = 2507 (  pg_get_indexdef       PGNSP PGUID 12 f f t f s 3 25 "26 23 16"  pg_get_indexdef - _null_
));
+ DESCR("index description (full create statement or single expression) with pretty-print option");
+ DATA(insert OID = 2508 (  pg_get_constraintdef PGNSP PGUID 12 f f t f s 2 25 "26 16"  pg_get_constraintdef - _null_
));
+ DESCR("constraint description with pretty-print option");
+ DATA(insert OID = 2509 (  pg_get_expr           PGNSP PGUID 12 f f t f s 3 25 "25 26 16"    pg_get_expr - _null_ ));
+ DESCR("deparse an encoded expression with pretty-print option");
+

  /*
   * Symbolic values for provolatile column: these indicate whether the result


pgsql-patches by date:

Previous
From: Joe Conway
Date:
Subject: Re: [HACKERS] allowed user/db variables
Next
From: Bruce Momjian
Date:
Subject: Re: [HACKERS] PATCH: Memory leaks on start-up