Fix up pg_dump to do string escaping fully correctly for client encoding

and standard_conforming_strings; likewise for the other client programs
that need it.  As per previous discussion, a pg_dump dump now conforms
to the standard_conforming_strings setting of the source database.
We don't use E'' syntax in the dump, thereby improving portability of
the SQL.  I added a SET escape_strings_warning = off command to keep
the dumps from getting a lot of back-chatter from that.

Author: tglsfdc

src/backend/utils/adt/quote.c

@@ -7,14 +7,13 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/utils/adt/quote.c,v 1.19 2006/05/26 23:48:54 momjian Exp $
+ *	  $PostgreSQL: pgsql/src/backend/utils/adt/quote.c,v 1.20 2006/05/28 21:13:53 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
 #include "postgres.h"
 
 #include "utils/builtins.h"
-#include "parser/gramparse.h"
 
 
 /*
@@ -49,6 +48,12 @@ quote_ident(PG_FUNCTION_ARGS)
 /*
  * quote_literal -
  *	  returns a properly quoted literal
+ *
+ * NOTE: think not to make this function's behavior change with
+ * standard_conforming_strings.  We don't know where the result
+ * literal will be used, and so we must generate a result that
+ * will work with either setting.  Take a look at what dblink
+ * uses this for before thinking you know better.
  */
 Datum
 quote_literal(PG_FUNCTION_ARGS)
@@ -66,20 +71,22 @@ quote_literal(PG_FUNCTION_ARGS)
 	cp1 = VARDATA(t);
 	cp2 = VARDATA(result);
 
-	if (!standard_conforming_strings)
-		for (; len-- > 0; cp1++)
-			if (*cp1 == '\\')
-			{
-				*cp2++ = ESCAPE_STRING_SYNTAX;
-				break;
-			}
+	for (; len-- > 0; cp1++)
+	{
+		if (*cp1 == '\\')
+		{
+			*cp2++ = ESCAPE_STRING_SYNTAX;
+			break;
+		}
+	}
 
 	len = VARSIZE(t) - VARHDRSZ;
 	cp1 = VARDATA(t);
+
 	*cp2++ = '\'';
 	while (len-- > 0)
 	{
-		if (SQL_STR_DOUBLE(*cp1, !standard_conforming_strings))
+		if (SQL_STR_DOUBLE(*cp1, true))
 			*cp2++ = *cp1;
 		*cp2++ = *cp1++;
 	}

src/backend/utils/adt/ruleutils.c

@@ -2,7 +2,7 @@
  * ruleutils.c	- Functions to convert stored expressions/querytrees
  *				back to source text
  *
- *	  $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.222 2006/05/26 23:48:54 momjian Exp $
+ *	  $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.223 2006/05/28 21:13:53 tgl Exp $
  **********************************************************************/
 
 #include "postgres.h"
@@ -534,18 +534,23 @@ pg_get_triggerdef(PG_FUNCTION_ARGS)
 		{
 			if (i > 0)
 				appendStringInfo(&buf, ", ");
-			if (!standard_conforming_strings && strchr(p, '\\') != NULL)
-				appendStringInfoChar(&buf, ESCAPE_STRING_SYNTAX);
+			/*
+			 * We form the string literal according to the prevailing setting
+			 * of standard_conforming_strings; we never use E''.
+			 * User is responsible for making sure result is used correctly.
+			 */
 			appendStringInfoChar(&buf, '\'');
-
 			while (*p)
 			{
-				if (SQL_STR_DOUBLE(*p, !standard_conforming_strings))
-					appendStringInfoChar(&buf, *p);
-				appendStringInfoChar(&buf, *p++);
+				char		ch = *p++;
+
+				if (SQL_STR_DOUBLE(ch, !standard_conforming_strings))
+					appendStringInfoChar(&buf, ch);
+				appendStringInfoChar(&buf, ch);
 			}
-			p++;
 			appendStringInfoChar(&buf, '\'');
+			/* advance p to next string embedded in tgargs */
+			p++;
 		}
 	}
 
@@ -3883,8 +3888,7 @@ get_const_expr(Const *constval, deparse_context *context)
 	char	   *valptr;
 	bool		isfloat = false;
 	bool		needlabel;
-	bool		is_e_string = false;
-	
+
 	if (constval->constisnull)
 	{
 		/*
@@ -3946,32 +3950,18 @@ get_const_expr(Const *constval, deparse_context *context)
 		default:
 
 			/*
-			 * We must quote any funny characters in the constant's
-			 * representation. XXX Any MULTIBYTE considerations here?
+			 * We form the string literal according to the prevailing setting
+			 * of standard_conforming_strings; we never use E''.
+			 * User is responsible for making sure result is used correctly.
 			 */
-			for (valptr = extval; *valptr; valptr++)
-				if ((!standard_conforming_strings && *valptr == '\\') ||
-					(unsigned char) *valptr < (unsigned char) ' ')
-				{
-					appendStringInfoChar(buf, ESCAPE_STRING_SYNTAX);
-					is_e_string = true;
-					break;
-				}
-
 			appendStringInfoChar(buf, '\'');
 			for (valptr = extval; *valptr; valptr++)
 			{
 				char		ch = *valptr;
 
-				if (SQL_STR_DOUBLE(ch, is_e_string))
-				{
-					appendStringInfoChar(buf, ch);
-					appendStringInfoChar(buf, ch);
-				}
-				else if ((unsigned char) ch < (unsigned char) ' ')
-					appendStringInfo(buf, "\\%03o", (int) ch);
-				else
+				if (SQL_STR_DOUBLE(ch, !standard_conforming_strings))
 					appendStringInfoChar(buf, ch);
+				appendStringInfoChar(buf, ch);
 			}
 			appendStringInfoChar(buf, '\'');
 			break;

src/bin/pg_dump/dumputils.c

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/bin/pg_dump/dumputils.c,v 1.28 2006/05/26 23:48:54 momjian Exp $
+ * $PostgreSQL: pgsql/src/bin/pg_dump/dumputils.c,v 1.29 2006/05/28 21:13:54 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -100,63 +100,102 @@ fmtId(const char *rawid)
 
 /*
  * Convert a string value to an SQL string literal and append it to
- * the given buffer.
+ * the given buffer.  We assume the specified client_encoding and
+ * standard_conforming_strings settings.
  *
- * Special characters are escaped. Quote mark ' goes to '' per SQL
- * standard, other stuff goes to \ sequences.  If escapeAll is false,
- * whitespace characters are not escaped (tabs, newlines, etc.).  This
- * is appropriate for dump file output.  Using E'' strings for
- * backslashes is always safe for standard_conforming_strings on or off.
+ * This is essentially equivalent to libpq's PQescapeStringInternal,
+ * except for the output buffer structure.  We need it in situations
+ * where we do not have a PGconn available.  Where we do,
+ * appendStringLiteralConn is a better choice.
  */
 void
-appendStringLiteral(PQExpBuffer buf, const char *str, bool escapeAll,
-					bool e_string_for_backslash)
+appendStringLiteral(PQExpBuffer buf, const char *str,
+					int encoding, bool std_strings)
 {
-	char		ch;
-	const char *p;
-	bool		is_e_string = false;
+	size_t		length = strlen(str);
+	const char *source = str;
+	char	   *target;
 
-	for (p = str; *p; p++)
+	if (!enlargePQExpBuffer(buf, 2 * length + 2))
+		return;
+
+	target = buf->data + buf->len;
+	*target++ = '\'';
+
+	while (*source != '\0')
 	{
-		ch = *p;
+		char	c = *source;
+		int		len;
+		int		i;
 
-		if ((e_string_for_backslash && ch == '\\') ||
-			((unsigned char) ch < (unsigned char) ' ' &&
-			 (escapeAll ||
-			  (ch != '\t' && ch != '\n' && ch != '\v' &&
-			   ch != '\f' && ch != '\r'))))
+		/* Fast path for plain ASCII */
+		if (!IS_HIGHBIT_SET(c))
 		{
-			appendPQExpBufferChar(buf, ESCAPE_STRING_SYNTAX);
-			is_e_string = true;
-			break;
+			/* Apply quoting if needed */
+			if (SQL_STR_DOUBLE(c, !std_strings))
+				*target++ = c;
+			/* Copy the character */
+			*target++ = c;
+			source++;
+			continue;
 		}
-	}
 
-	appendPQExpBufferChar(buf, '\'');
-	for (p = str; *p; p++)
-	{
-		ch = *p;
-		if (SQL_STR_DOUBLE(ch, is_e_string))
+		/* Slow path for possible multibyte characters */
+		len = PQmblen(source, encoding);
+
+		/* Copy the character */
+		for (i = 0; i < len; i++)
 		{
-			appendPQExpBufferChar(buf, ch);
-			appendPQExpBufferChar(buf, ch);
+			if (*source == '\0')
+				break;
+			*target++ = *source++;
 		}
-		else if ((unsigned char) ch < (unsigned char) ' ' &&
-				 (escapeAll ||
-				  (ch != '\t' && ch != '\n' && ch != '\v' &&
-				   ch != '\f' && ch != '\r')))
+
+		/*
+		 * If we hit premature end of string (ie, incomplete multibyte
+		 * character), try to pad out to the correct length with spaces.
+		 * We may not be able to pad completely, but we will always be able
+		 * to insert at least one pad space (since we'd not have quoted a
+		 * multibyte character).  This should be enough to make a string that
+		 * the server will error out on.
+		 */
+		if (i < len)
 		{
-			/*
-			 * generate octal escape for control chars other than whitespace
-			 */
-			appendPQExpBufferChar(buf, '\\');
-			appendPQExpBufferChar(buf, ((ch >> 6) & 3) + '0');
-			appendPQExpBufferChar(buf, ((ch >> 3) & 7) + '0');
-			appendPQExpBufferChar(buf, (ch & 7) + '0');
+			char   *stop = buf->data + buf->maxlen - 2;
+
+			for (; i < len; i++)
+			{
+				if (target >= stop)
+					break;
+				*target++ = ' ';
+			}
+			break;
 		}
-		else
-			appendPQExpBufferChar(buf, ch);
 	}
+
+	/* Write the terminating quote and NUL character. */
+	*target++ = '\'';
+	*target = '\0';
+
+	buf->len = target - buf->data;
+}
+
+
+/*
+ * Convert a string value to an SQL string literal and append it to
+ * the given buffer.  Encoding and string syntax rules are as indicated
+ * by current settings of the PGconn.
+ */
+void
+appendStringLiteralConn(PQExpBuffer buf, const char *str, PGconn *conn)
+{
+	size_t	length = strlen(str);
+
+	if (!enlargePQExpBuffer(buf, 2 * length + 2))
+		return;
+	appendPQExpBufferChar(buf, '\'');
+	buf->len += PQescapeStringConn(conn, buf->data + buf->len,
+								   str, length, NULL);
 	appendPQExpBufferChar(buf, '\'');
 }
 
@@ -167,7 +206,8 @@ appendStringLiteral(PQExpBuffer buf, const char *str, bool escapeAll,
  * dollar quote delimiter will begin with that (after the opening $).
  *
  * No escaping is done at all on str, in compliance with the rules
- * for parsing dollar quoted strings.
+ * for parsing dollar quoted strings.  Also, we need not worry about
+ * encoding issues.
  */
 void
 appendStringLiteralDQ(PQExpBuffer buf, const char *str, const char *dqprefix)
@@ -204,21 +244,6 @@ appendStringLiteralDQ(PQExpBuffer buf, const char *str, const char *dqprefix)
 }
 
 
-/*
- * Use dollar quoting if the string to be quoted contains ' or \,
- * otherwise use standard quoting.
- */
-void
-appendStringLiteralDQOpt(PQExpBuffer buf, const char *str,
-						 bool escapeAll, const char *dqprefix)
-{
-	if (strchr(str, '\'') == NULL && strchr(str, '\\') == NULL)
-		appendStringLiteral(buf, str, escapeAll, true);
-	else
-		appendStringLiteralDQ(buf, str, dqprefix);
-}
-
-
 /*
  * Convert backend's version string into a number.
  */

src/bin/pg_dump/dumputils.h

@@ -7,23 +7,24 @@
  * Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/bin/pg_dump/dumputils.h,v 1.16 2006/05/26 23:48:54 momjian Exp $
+ * $PostgreSQL: pgsql/src/bin/pg_dump/dumputils.h,v 1.17 2006/05/28 21:13:54 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
 
 #ifndef DUMPUTILS_H
 #define DUMPUTILS_H
 
+#include "libpq-fe.h"
 #include "pqexpbuffer.h"
 
 extern const char *fmtId(const char *identifier);
 extern void appendStringLiteral(PQExpBuffer buf, const char *str,
-					bool escapeAll, bool e_string_for_backslash);
+								int encoding, bool std_strings);
+extern void appendStringLiteralConn(PQExpBuffer buf, const char *str,
+									PGconn *conn);
 extern void appendStringLiteralDQ(PQExpBuffer buf, const char *str,
 					  const char *dqprefix);
-extern void appendStringLiteralDQOpt(PQExpBuffer buf, const char *str,
-						 bool escapeAll, const char *dqprefix);
 extern int	parse_version(const char *versionString);
 extern bool parsePGArray(const char *atext, char ***itemarray, int *nitems);
 extern bool buildACLCommands(const char *name, const char *type,

src/bin/pg_dump/pg_backup.h

@@ -15,7 +15,7 @@
  *
  *
  * IDENTIFICATION
- *		$PostgreSQL: pgsql/src/bin/pg_dump/pg_backup.h,v 1.38 2006/02/12 04:04:32 momjian Exp $
+ *		$PostgreSQL: pgsql/src/bin/pg_dump/pg_backup.h,v 1.39 2006/05/28 21:13:54 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -60,6 +60,10 @@ typedef struct _Archive
 	int			minRemoteVersion;		/* allowable range */
 	int			maxRemoteVersion;
 
+	/* info needed for string escaping */
+	int			encoding;		/* libpq code for client_encoding */
+	bool		std_strings;	/* standard_conforming_strings */
+
 	/* error handling */
 	bool		exit_on_error;	/* whether to exit on SQL errors... */
 	int			n_errors;		/* number of errors (if no die) */
@@ -182,4 +186,7 @@ archprintf(Archive *AH, const char *fmt,...)
 /* This extension allows gcc to check the format string */
 __attribute__((format(printf, 2, 3)));
 
+#define appendStringLiteralAH(buf,str,AH) \
+	appendStringLiteral(buf, str, (AH)->encoding, (AH)->std_strings)
+
 #endif   /* PG_BACKUP_H */