Adjust processSQLNamePattern() so that $ within the pattern is always matched

literally, whether quoted or not.  Since we allow $ as a character within
identifiers, this behavior is useful, whereas the previous behavior of
treating it as the regexp ending anchor was nearly useless given that the
pattern is automatically anchored anyway.  This affects the arguments of
psql's \d commands as well as pg_dump's -n and -t switches.  Per discussion.

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 9b3b1a5095f860f87543c57546d1fe06efcd9d27..b349e56ec4aa727317f760442fe9c53733d6476b 100644 (file)
--- a/doc/src/sgml/ref/psql-ref.sgml
+++ b/doc/src/sgml/ref/psql-ref.sgml
@@ -1916,8 +1916,8 @@ lo_import 152801
   <para>
    A pattern that contains a dot (<literal>.</>) is interpreted as a schema
    name pattern followed by an object name pattern.  For example,
-   <literal>\dt foo*.bar*</> displays all tables whose table name
-   starts with <literal>bar</> that are in schemas whose schema name
+   <literal>\dt foo*.*bar*</> displays all tables whose table name
+   includes <literal>bar</> that are in schemas whose schema name
    starts with <literal>foo</>.  When no dot appears, then the pattern
    matches only objects that are visible in the current schema search path.
    Again, a dot within double quotes loses its special meaning and is matched
@@ -1930,17 +1930,20 @@ lo_import 152801
    expression special characters work as specified in
    <xref linkend="functions-posix-regexp">, except for <literal>.</> which
    is taken as a separator as mentioned above, <literal>*</> which is
-   translated to the regular-expression notation <literal>.*</>, and
-   <literal>?</> which is translated to <literal>.</>.  You can emulate
+   translated to the regular-expression notation <literal>.*</>,
+   <literal>?</> which is translated to <literal>.</>, and
+   <literal>$</> which is matched literally.  You can emulate
    these pattern characters at need by writing
    <literal>?</> for <literal>.</>,
    <literal>(<replaceable class="parameter">R</replaceable>+|)</literal> for
    <literal><replaceable class="parameter">R</replaceable>*</literal>, or
    <literal>(<replaceable class="parameter">R</replaceable>|)</literal> for
    <literal><replaceable class="parameter">R</replaceable>?</literal>.
-   Remember that the pattern must match the whole name, unlike the usual
-   interpretation of regular expressions; write <literal>*</> at the beginning
-   and/or end if you don't wish the pattern to be anchored.
+   <literal>$</> is not needed as a regular-expression character since
+   the pattern must match the whole name, unlike the usual
+   interpretation of regular expressions (in other words, <literal>$</>
+   is automatically appended to your pattern).  Write <literal>*</> at the
+   beginning and/or end if you don't wish the pattern to be anchored.
    Note that within double quotes, all regular expression special characters
    lose their special meanings and are matched literally.  Also, the regular
    expression special characters are matched literally in operator name

diff --git a/src/bin/pg_dump/dumputils.c b/src/bin/pg_dump/dumputils.c
index e861d7a12843b2e8256b6e70bd8ac78a1a98d8a8..096930c9503f08fa05148ec1cf75366ecda56a1a 100644 (file)
--- a/src/bin/pg_dump/dumputils.c
+++ b/src/bin/pg_dump/dumputils.c
@@ -872,6 +872,18 @@ processSQLNamePattern(PGconn *conn, PQExpBuffer buf, const char *pattern,
                        appendPQExpBufferStr(&namebuf, "^(");
                        cp++;
                }
+               else if (ch == '$')
+               {
+                       /*
+                        * Dollar is always quoted, whether inside quotes or not.
+                        * The reason is that it's allowed in SQL identifiers, so
+                        * there's a significant use-case for treating it literally,
+                        * while because we anchor the pattern automatically there is
+                        * no use-case for having it possess its regexp meaning.
+                        */
+                       appendPQExpBufferStr(&namebuf, "\\$");
+                       cp++;
+               }
                else
                {
                        /*