Remove regex_flavor GUC, so that regular expressions are always "advanced"

style by default.  Per discussion, there seems to be hardly anything that
really relies on being able to change the regex flavor, so the ability to
select it via embedded options ought to be enough for any stragglers.
Also, if we didn't remove the GUC, we'd really be morally obligated to
mark the regex functions non-immutable, which'd possibly create performance
issues.

Author: tglsfdc

doc/src/sgml/config.sgml

@@ -1,4 +1,4 @@
-<!-- $PostgreSQL: pgsql/doc/src/sgml/config.sgml,v 1.231 2009/10/21 20:22:38 tgl Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/config.sgml,v 1.232 2009/10/21 20:38:58 tgl Exp $ -->
 
 <chapter Id="runtime-config">
   <title>Server Configuration</title>
@@ -4772,24 +4772,6 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </listitem>
      </varlistentry>
 
-     <varlistentry id="guc-regex-flavor" xreflabel="regex_flavor">
-      <term><varname>regex_flavor</varname> (<type>enum</type>)</term>
-      <indexterm><primary>regular expressions</></>
-      <indexterm>
-       <primary><varname>regex_flavor</> configuration parameter</primary>
-      </indexterm>
-      <listitem>
-       <para>
-        The regular expression <quote>flavor</> can be set to
-        <literal>advanced</>, <literal>extended</>, or <literal>basic</>.
-        The default is <literal>advanced</>.  The <literal>extended</>
-        setting might be useful for exact backwards compatibility with
-        pre-7.4 releases of <productname>PostgreSQL</>.  See
-        <xref linkend="posix-syntax-details"> for details.
-       </para>
-      </listitem>
-     </varlistentry>
-
      <varlistentry id="guc-sql-inheritance" xreflabel="sql_inheritance">
       <term><varname>sql_inheritance</varname> (<type>boolean</type>)</term>
       <indexterm>

doc/src/sgml/func.sgml

@@ -1,4 +1,4 @@
-<!-- $PostgreSQL: pgsql/doc/src/sgml/func.sgml,v 1.490 2009/10/13 22:46:13 petere Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/func.sgml,v 1.491 2009/10/21 20:38:58 tgl Exp $ -->
 
  <chapter id="functions">
   <title>Functions and Operators</title>
@@ -3308,8 +3308,7 @@ substring('foobar' from '#"o_b#"%' for '#')    <lineannotation>NULL</lineannotat
 
     <para>
      <acronym>POSIX</acronym> regular expressions provide a more
-     powerful means for 
-     pattern matching than the <function>LIKE</function> and
+     powerful means for pattern matching than the <function>LIKE</function> and
      <function>SIMILAR TO</> operators.
      Many Unix tools such as <command>egrep</command>,
      <command>sed</command>, or <command>awk</command> use a pattern
@@ -3572,12 +3571,12 @@ SELECT foo FROM regexp_split_to_table('the quick brown fox', E'\\s*') AS foo;
 
    <note>
     <para>
-     The form of regular expressions accepted by
-     <productname>PostgreSQL</> can be chosen by setting the <xref
-     linkend="guc-regex-flavor"> run-time parameter.  The usual
-     setting is <literal>advanced</>, but one might choose
-     <literal>extended</> for backwards compatibility with
-     pre-7.4 releases of <productname>PostgreSQL</>.
+     <productname>PostgreSQL</> always initially presumes that a regular
+     expression follows the ARE rules.  However, the more limited ERE or
+     BRE rules can be chosen by prepending an <firstterm>embedded option</>
+     to the RE pattern, as described in <xref linkend="posix-metasyntax">.
+     This can be useful for compatibility with applications that expect
+     exactly the <acronym>POSIX</acronym> 1003.2 rules.
     </para>
    </note>
 
@@ -4278,7 +4277,7 @@ SELECT foo FROM regexp_split_to_table('the quick brown fox', E'\\s*') AS foo;
        <entry> (where <replaceable>m</> is a nonzero digit, and
        <replaceable>nn</> is some more digits, and the decimal value
        <replaceable>mnn</> is not greater than the number of closing capturing
-       parentheses seen so far) 
+       parentheses seen so far)
        a back reference to the <replaceable>mnn</>'th subexpression </entry>
        </row>
       </tbody>
@@ -4310,12 +4309,12 @@ SELECT foo FROM regexp_split_to_table('the quick brown fox', E'\\s*') AS foo;
    </para>
 
    <para>
-    Normally the flavor of RE being used is determined by
-    <varname>regex_flavor</>.
-    However, this can be overridden by a <firstterm>director</> prefix.
+    An RE can begin with one of two special <firstterm>director</> prefixes.
     If an RE begins with <literal>***:</>,
-    the rest of the RE is taken as an ARE regardless of
-    <varname>regex_flavor</>.
+    the rest of the RE is taken as an ARE.  (This normally has no effect in
+    <productname>PostgreSQL</>, since REs are assumed to be AREs;
+    but it does have an effect if ERE or BRE mode had been specified by
+    the <replaceable>flags</> parameter to a regex function.)
     If an RE begins with <literal>***=</>,
     the rest of the RE is taken to be a literal string,
     with all characters considered ordinary characters.
@@ -4326,10 +4325,14 @@ SELECT foo FROM regexp_split_to_table('the quick brown fox', E'\\s*') AS foo;
     a sequence <literal>(?</><replaceable>xyz</><literal>)</>
     (where <replaceable>xyz</> is one or more alphabetic characters)
     specifies options affecting the rest of the RE.
-    These options override any previously determined options (including
-    both the RE flavor and case sensitivity).
+    These options override any previously determined options &mdash;
+    in particular, they can override the case-sensitivity behavior implied by
+    a regex operator, or the <replaceable>flags</> parameter to a regex
+    function.
     The available option letters are
     shown in <xref linkend="posix-embedded-options-table">.
+    Note that these same option letters are used in the <replaceable>flags</>
+    parameters of regex functions.
    </para>
 
    <table id="posix-embedded-options-table">
@@ -4700,10 +4703,6 @@ SELECT SUBSTRING('XY1234Z', 'Y*?([0-9]{1,3})');
       </para>
      </listitem>
     </itemizedlist>
-
-    While these differences are unlikely to create a problem for most
-    applications, you can avoid them if necessary by
-    setting <varname>regex_flavor</> to <literal>extended</>.
    </para>
    </sect3>
 

src/backend/utils/adt/regexp.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/utils/adt/regexp.c,v 1.83 2009/10/10 03:50:15 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/utils/adt/regexp.c,v 1.84 2009/10/21 20:38:58 tgl Exp $
  *
  *		Alistair Crooks added the code for the regex caching
  *		agc - cached the regular expressions used - there's a good chance
@@ -39,10 +39,6 @@
 	(PG_NARGS() > (_n) ? PG_GETARG_TEXT_PP(_n) : NULL)
 
 
-/* GUC-settable flavor parameter */
-int			regex_flavor = REG_ADVANCED;
-
-
 /* all the options of interest for regex functions */
 typedef struct pg_re_flags
 {
@@ -347,8 +343,8 @@ RE_compile_and_execute(text *text_re, char *dat, int dat_len,
 static void
 parse_re_flags(pg_re_flags *flags, text *opts)
 {
-	/* regex_flavor is always folded into the compile flags */
-	flags->cflags = regex_flavor;
+	/* regex flavor is always folded into the compile flags */
+	flags->cflags = REG_ADVANCED;
 	flags->glob = false;
 
 	if (opts)
@@ -414,16 +410,6 @@ parse_re_flags(pg_re_flags *flags, text *opts)
 }
 
 
-/*
- * report whether regex_flavor is currently BASIC
- */
-bool
-regex_flavor_is_basic(void)
-{
-	return (regex_flavor == REG_BASIC);
-}
-
-
 /*
  *	interface routines called by the function manager
  */
@@ -437,7 +423,7 @@ nameregexeq(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(RE_compile_and_execute(p,
 										  NameStr(*n),
 										  strlen(NameStr(*n)),
-										  regex_flavor,
+										  REG_ADVANCED,
 										  0, NULL));
 }
 
@@ -450,7 +436,7 @@ nameregexne(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(!RE_compile_and_execute(p,
 										   NameStr(*n),
 										   strlen(NameStr(*n)),
-										   regex_flavor,
+										   REG_ADVANCED,
 										   0, NULL));
 }
 
@@ -463,7 +449,7 @@ textregexeq(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(RE_compile_and_execute(p,
 										  VARDATA_ANY(s),
 										  VARSIZE_ANY_EXHDR(s),
-										  regex_flavor,
+										  REG_ADVANCED,
 										  0, NULL));
 }
 
@@ -476,7 +462,7 @@ textregexne(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(!RE_compile_and_execute(p,
 										   VARDATA_ANY(s),
 										   VARSIZE_ANY_EXHDR(s),
-										   regex_flavor,
+										   REG_ADVANCED,
 										   0, NULL));
 }
 
@@ -496,7 +482,7 @@ nameicregexeq(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(RE_compile_and_execute(p,
 										  NameStr(*n),
 										  strlen(NameStr(*n)),
-										  regex_flavor | REG_ICASE,
+										  REG_ADVANCED | REG_ICASE,
 										  0, NULL));
 }
 
@@ -509,7 +495,7 @@ nameicregexne(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(!RE_compile_and_execute(p,
 										   NameStr(*n),
 										   strlen(NameStr(*n)),
-										   regex_flavor | REG_ICASE,
+										   REG_ADVANCED | REG_ICASE,
 										   0, NULL));
 }
 
@@ -522,7 +508,7 @@ texticregexeq(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(RE_compile_and_execute(p,
 										  VARDATA_ANY(s),
 										  VARSIZE_ANY_EXHDR(s),
-										  regex_flavor | REG_ICASE,
+										  REG_ADVANCED | REG_ICASE,
 										  0, NULL));
 }
 
@@ -535,7 +521,7 @@ texticregexne(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(!RE_compile_and_execute(p,
 										   VARDATA_ANY(s),
 										   VARSIZE_ANY_EXHDR(s),
-										   regex_flavor | REG_ICASE,
+										   REG_ADVANCED | REG_ICASE,
 										   0, NULL));
 }
 
@@ -555,7 +541,7 @@ textregexsubstr(PG_FUNCTION_ARGS)
 				eo;
 
 	/* Compile RE */
-	re = RE_compile_and_cache(p, regex_flavor);
+	re = RE_compile_and_cache(p, REG_ADVANCED);
 
 	/*
 	 * We pass two regmatch_t structs to get info about the overall match and
@@ -611,7 +597,7 @@ textregexreplace_noopt(PG_FUNCTION_ARGS)
 	text	   *r = PG_GETARG_TEXT_PP(2);
 	regex_t    *re;
 
-	re = RE_compile_and_cache(p, regex_flavor);
+	re = RE_compile_and_cache(p, REG_ADVANCED);
 
 	PG_RETURN_TEXT_P(replace_text_regexp(s, (void *) re, r, false));
 }
@@ -684,12 +670,10 @@ similar_escape(PG_FUNCTION_ARGS)
 
 	/*----------
 	 * We surround the transformed input string with
-	 *			***:^(?: ... )$
-	 * which is bizarre enough to require some explanation.  "***:" is a
-	 * director prefix to force the regex to be treated as an ARE regardless
-	 * of the current regex_flavor setting.  We need "^" and "$" to force
-	 * the pattern to match the entire input string as per SQL99 spec.	The
-	 * "(?:" and ")" are a non-capturing set of parens; we have to have
+	 *			^(?: ... )$
+	 * which requires some explanation.  We need "^" and "$" to force
+	 * the pattern to match the entire input string as per SQL99 spec.
+	 * The "(?:" and ")" are a non-capturing set of parens; we have to have
 	 * parens in case the string contains "|", else the "^" and "$" will
 	 * be bound into the first and last alternatives which is not what we
 	 * want, and the parens must be non capturing because we don't want them
@@ -701,13 +685,9 @@ similar_escape(PG_FUNCTION_ARGS)
 	 * We need room for the prefix/postfix plus as many as 2 output bytes per
 	 * input byte
 	 */
-	result = (text *) palloc(VARHDRSZ + 10 + 2 * plen);
+	result = (text *) palloc(VARHDRSZ + 6 + 2 * plen);
 	r = VARDATA(result);
 
-	*r++ = '*';
-	*r++ = '*';
-	*r++ = '*';
-	*r++ = ':';
 	*r++ = '^';
 	*r++ = '(';
 	*r++ = '?';

src/backend/utils/adt/selfuncs.c

@@ -15,7 +15,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.262 2009/08/04 16:08:36 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.263 2009/10/21 20:38:58 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -4580,7 +4580,6 @@ regex_fixed_prefix(Const *patt_const, bool case_insensitive,
 	char	   *patt;
 	char	   *rest;
 	Oid			typeid = patt_const->consttype;
-	bool		is_basic = regex_flavor_is_basic();
 	bool		is_multibyte = (pg_database_encoding_max_length() > 1);
 
 	/*
@@ -4598,14 +4597,12 @@ regex_fixed_prefix(Const *patt_const, bool case_insensitive,
 
 	/*
 	 * Check for ARE director prefix.  It's worth our trouble to recognize
-	 * this because similar_escape() uses it.
+	 * this because similar_escape() used to use it, and some other code
+	 * might still use it, to force ARE mode.
 	 */
 	pos = 0;
 	if (strncmp(patt, "***:", 4) == 0)
-	{
 		pos = 4;
-		is_basic = false;
-	}
 
 	/* Pattern must be anchored left */
 	if (patt[pos] != '^')
@@ -4641,17 +4638,11 @@ regex_fixed_prefix(Const *patt_const, bool case_insensitive,
 
 	/*
 	 * We special-case the syntax '^(...)$' because psql uses it.  But beware:
-	 * in BRE mode these parentheses are just ordinary characters.	Also,
 	 * sequences beginning "(?" are not what they seem, unless they're "(?:".
-	 * (We should recognize that, too, because of similar_escape().)
-	 *
-	 * Note: it's a bit bogus to be depending on the current regex_flavor
-	 * setting here, because the setting could change before the pattern is
-	 * used.  We minimize the risk by trusting the flavor as little as we can,
-	 * but perhaps it would be a good idea to get rid of the "basic" setting.
+	 * (We must recognize that because of similar_escape().)
 	 */
 	have_leading_paren = false;
-	if (patt[pos] == '(' && !is_basic &&
+	if (patt[pos] == '(' &&
 		(patt[pos + 1] != '?' || patt[pos + 2] == ':'))
 	{
 		have_leading_paren = true;
@@ -4691,12 +4682,10 @@ regex_fixed_prefix(Const *patt_const, bool case_insensitive,
 		/*
 		 * Check for quantifiers.  Except for +, this means the preceding
 		 * character is optional, so we must remove it from the prefix too!
-		 * Note: in BREs, \{ is a quantifier.
 		 */
 		if (patt[pos] == '*' ||
 			patt[pos] == '?' ||
-			patt[pos] == '{' ||
-			(patt[pos] == '\\' && patt[pos + 1] == '{'))
+			patt[pos] == '{')
 		{
 			match_pos = prev_match_pos;
 			pos = prev_pos;
@@ -4711,14 +4700,13 @@ regex_fixed_prefix(Const *patt_const, bool case_insensitive,
 		/*
 		 * Normally, backslash quotes the next character.  But in AREs,
 		 * backslash followed by alphanumeric is an escape, not a quoted
-		 * character.  Must treat it as having multiple possible matches. In
-		 * BREs, \( is a parenthesis, so don't trust that either. Note: since
-		 * only ASCII alphanumerics are escapes, we don't have to be paranoid
-		 * about multibyte here.
+		 * character.  Must treat it as having multiple possible matches.
+		 * Note: since only ASCII alphanumerics are escapes, we don't have to
+		 * be paranoid about multibyte here.
 		 */
 		if (patt[pos] == '\\')
 		{
-			if (isalnum((unsigned char) patt[pos + 1]) || patt[pos + 1] == '(')
+			if (isalnum((unsigned char) patt[pos + 1]))
 				break;
 			pos++;
 			if (patt[pos] == '\0')