Optimizing COPY with SIMD

From 7c8742685dee201f4fc182143dbcc6587f90a8f9 Mon Sep 17 00:00:00 2001
From: Neil Conway <neil@determined.ai>
Date: Sun, 2 Jun 2024 12:01:48 -0400
Subject: [PATCH v2 1/4] Adjust misleading comment placement

---
 src/backend/commands/copyto.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/backend/commands/copyto.c b/src/backend/commands/copyto.c
index ae8b2e36d7..cd2d7bb217 100644
--- a/src/backend/commands/copyto.c
+++ b/src/backend/commands/copyto.c
@@ -969,15 +969,15 @@ CopyOneRowTo(CopyToState cstate, TupleTableSlot *slot)
 	MemoryContextSwitchTo(oldcontext);
 }
 
-/*
- * Send text representation of one attribute, with conversion and escaping
- */
 #define DUMPSOFAR() \
 	do { \
 		if (ptr > start) \
 			CopySendData(cstate, start, ptr - start); \
 	} while (0)
 
+/*
+ * Send text representation of one attribute, with conversion and escaping
+ */
 static void
 CopyAttributeOutText(CopyToState cstate, const char *string)
 {
-- 
2.39.3 (Apple Git-146)

From 39650379c974d64631960510be12d88595249641 Mon Sep 17 00:00:00 2001
From: Neil Conway <neil@determined.ai>
Date: Sun, 2 Jun 2024 18:50:30 -0400
Subject: [PATCH v2 2/4] Improve COPY test coverage for handling of control
 characters

---
 src/test/regress/expected/copy2.out | 38 +++++++++++++++++++++++++++++
 src/test/regress/sql/copy2.sql      | 25 +++++++++++++++++++
 2 files changed, 63 insertions(+)

diff --git a/src/test/regress/expected/copy2.out b/src/test/regress/expected/copy2.out
index 931542f268..be654daf4a 100644
--- a/src/test/regress/expected/copy2.out
+++ b/src/test/regress/expected/copy2.out
@@ -905,3 +905,41 @@ truncate copy_default;
 -- DEFAULT cannot be used in COPY TO
 copy (select 1 as test) TO stdout with (default '\D');
 ERROR:  COPY DEFAULT only available using COPY FROM
+-- Test handling of control characters
+create temp table copy_ctl (a text, b text);
+copy copy_ctl from stdin;
+copy copy_ctl to stdout;
+abc	def
+\n	def
+abc	\n
+\t	def
+abc	\t
+ab\b	\bdef
+a\vbc	def\v
+\f\f\f	g\fg
+\f	def
+abc	
+	def
+abc	
+\\	\n\t\\
+9	9999
+S4	j
+copy copy_ctl to stdout with (format csv);
+abc,def
+"
+",def
+abc,"
+"
+	,def
+abc,	
+ab,def
+abc,def
+,gg
+,def
+abc,
+,def
+abc,
+\,"
+	\"
+9,9999
+S4,j
diff --git a/src/test/regress/sql/copy2.sql b/src/test/regress/sql/copy2.sql
index 8b14962194..e8d495e024 100644
--- a/src/test/regress/sql/copy2.sql
+++ b/src/test/regress/sql/copy2.sql
@@ -676,3 +676,28 @@ truncate copy_default;
 
 -- DEFAULT cannot be used in COPY TO
 copy (select 1 as test) TO stdout with (default '\D');
+
+-- Test handling of control characters
+create temp table copy_ctl (a text, b text);
+
+copy copy_ctl from stdin;
+abc	def
+\n	def
+abc	\n
+\t	def
+abc	\t
+ab\b	\bdef
+a\vbc	def\v
+\f\f\f	g\fg
+\x0c	def
+abc	\x6
+\6	def
+abc	\017
+\\	\
+\	\\
+\9	\9999
+\1234	\j
+\.
+
+copy copy_ctl to stdout;
+copy copy_ctl to stdout with (format csv);
-- 
2.39.3 (Apple Git-146)

From a00c3354b126e39ce057d910a3a040f96e1491d3 Mon Sep 17 00:00:00 2001
From: Neil Conway <neil@determined.ai>
Date: Sun, 2 Jun 2024 14:00:58 -0400
Subject: [PATCH v2 3/4] Optimize COPY TO in CSV format using SIMD

CopyAttributeOutCSV() does one or two byte-by-byte loops over the text of each
attribute, depending on whether quotation is required. Implementing this loops
using SIMD yields a significant speedup for long attribute values. For short
attribute values, performance is roughly unchanged.

We don't attempt to apply this optimization encoding_embeds_ascii is true,
because the required bookkeeping would be complicated.
---
 src/backend/commands/copyto.c | 152 +++++++++++++++++++++++++++++++++-
 1 file changed, 149 insertions(+), 3 deletions(-)

diff --git a/src/backend/commands/copyto.c b/src/backend/commands/copyto.c
index cd2d7bb217..9114bb1c48 100644
--- a/src/backend/commands/copyto.c
+++ b/src/backend/commands/copyto.c
@@ -29,6 +29,7 @@
 #include "mb/pg_wchar.h"
 #include "miscadmin.h"
 #include "pgstat.h"
+#include "port/simd.h"
 #include "storage/fd.h"
 #include "tcop/tcopprot.h"
 #include "utils/lsyscache.h"
@@ -1127,6 +1128,144 @@ CopyAttributeOutText(CopyToState cstate, const char *string)
 	DUMPSOFAR();
 }
 
+/*
+ * Send text representation of one attribute, with conversion and CSV-style
+ * escaping.  This is significantly faster for wide attributes, assuming that
+ * control characters are rare.
+ *
+ * This variant assumes that encoding_embeds_ascii is false.  This simplifies
+ * the implementation because we can look at arbitrary-sized chunks of bytes,
+ * without needing to go through the pg_encoding_mblen() machinery to ensure
+ * that multibyte characters don't cross chunk boundaries.  In principle we
+ * could combine vectorization with such encodings, but the bookkeeping
+ * required would be complicated.
+ */
+static void
+CopyAttributeOutCSVVector(CopyToState cstate, const char *ptr,
+						  bool use_quote)
+{
+	int			len;
+	int			vlen;
+	char		delimc = cstate->opts.delim[0];
+	char		quotec = cstate->opts.quote[0];
+	char		escapec = cstate->opts.escape[0];
+
+	len = strlen(ptr);
+	vlen = len & (int) (~(sizeof(Vector8) - 1));
+
+	/*
+	 * Make a preliminary pass to discover if it needs quoting
+	 */
+	if (!use_quote)
+	{
+		bool	single_attr = (list_length(cstate->attnumlist) == 1);
+
+		/*
+		 * Because '\.' can be a data value, quote it if it appears alone on a
+		 * line so it is not interpreted as the end-of-data marker.
+		 */
+		if (single_attr && strcmp(ptr, "\\.") == 0)
+			use_quote = true;
+		else
+		{
+			int		i;
+			Vector8 chunk;
+
+			for (i = 0; i < vlen; i += sizeof(Vector8))
+			{
+				vector8_load(&chunk, (const uint8 *) &ptr[i]);
+
+				if (vector8_has(chunk, (unsigned char) delimc) ||
+					vector8_has(chunk, (unsigned char) quotec) ||
+					vector8_has(chunk, (unsigned char) '\n') ||
+					vector8_has(chunk, (unsigned char) '\r'))
+				{
+					use_quote = true;
+					break;
+				}
+			}
+
+			/* Check the tail of the string */
+			if (!use_quote)
+			{
+				for (; i < len; i++)
+				{
+					char c = ptr[i];
+
+					if (c == delimc || c == quotec || c == '\n' || c == '\r')
+					{
+						use_quote = true;
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	if (use_quote)
+	{
+		int		i;
+		int		start_idx = 0;
+		Vector8 chunk;
+
+		CopySendChar(cstate, quotec);
+
+		for (i = 0; i < vlen; i += sizeof(Vector8))
+		{
+			vector8_load(&chunk, (const uint8 *) &ptr[i]);
+
+			if (vector8_has(chunk, (unsigned char) delimc) ||
+				vector8_has(chunk, (unsigned char) quotec))
+			{
+				/*
+				 * This chunk has one or more characters that require
+				 * escaping, so switch to byte-at-a-time processing
+				 */
+				for (int j = i; j < (i + sizeof(Vector8)); j++)
+				{
+					char c = ptr[j];
+
+					if (c == quotec || c == escapec)
+					{
+						if (j > start_idx)
+							CopySendData(cstate, ptr + start_idx, j - start_idx);
+
+						CopySendChar(cstate, escapec);
+						start_idx = j;
+					}
+				}
+			}
+		}
+
+		/* Process the tail of the string */
+		for (; i < len; i++)
+		{
+			char c = ptr[i];
+
+			if (c == quotec || c == escapec)
+			{
+				if (i > start_idx)
+					CopySendData(cstate, ptr + start_idx, i - start_idx);
+
+				CopySendChar(cstate, escapec);
+				start_idx = i;
+			}
+		}
+
+		/* Send any remaining text */
+		if (start_idx < len)
+			CopySendData(cstate, ptr + start_idx, len - start_idx);
+
+		CopySendChar(cstate, quotec);
+	}
+	else
+	{
+		/* If it doesn't need quoting, we can just dump it as-is */
+		CopySendData(cstate, ptr, len);
+	}
+}
+
+
 /*
  * Send text representation of one attribute, with conversion and
  * CSV-style escaping
@@ -1141,7 +1280,6 @@ CopyAttributeOutCSV(CopyToState cstate, const char *string,
 	char		delimc = cstate->opts.delim[0];
 	char		quotec = cstate->opts.quote[0];
 	char		escapec = cstate->opts.escape[0];
-	bool		single_attr = (list_length(cstate->attnumlist) == 1);
 
 	/* force quoting if it matches null_print (before conversion!) */
 	if (!use_quote && strcmp(string, cstate->opts.null_print) == 0)
@@ -1152,11 +1290,19 @@ CopyAttributeOutCSV(CopyToState cstate, const char *string,
 	else
 		ptr = string;
 
+	if (!cstate->encoding_embeds_ascii)
+	{
+		CopyAttributeOutCSVVector(cstate, ptr, use_quote);
+		return;
+	}
+
 	/*
 	 * Make a preliminary pass to discover if it needs quoting
 	 */
 	if (!use_quote)
 	{
+		bool	single_attr = (list_length(cstate->attnumlist) == 1);
+
 		/*
 		 * Because '\.' can be a data value, quote it if it appears alone on a
 		 * line so it is not interpreted as the end-of-data marker.
@@ -1174,7 +1320,7 @@ CopyAttributeOutCSV(CopyToState cstate, const char *string,
 					use_quote = true;
 					break;
 				}
-				if (IS_HIGHBIT_SET(c) && cstate->encoding_embeds_ascii)
+				if (IS_HIGHBIT_SET(c))
 					tptr += pg_encoding_mblen(cstate->file_encoding, tptr);
 				else
 					tptr++;
@@ -1198,7 +1344,7 @@ CopyAttributeOutCSV(CopyToState cstate, const char *string,
 				CopySendChar(cstate, escapec);
 				start = ptr;	/* we include char in next run */
 			}
-			if (IS_HIGHBIT_SET(c) && cstate->encoding_embeds_ascii)
+			if (IS_HIGHBIT_SET(c))
 				ptr += pg_encoding_mblen(cstate->file_encoding, ptr);
 			else
 				ptr++;
-- 
2.39.3 (Apple Git-146)

From 7f816d88ba3d9e3d2c2d65b4160af84885cf37d5 Mon Sep 17 00:00:00 2001
From: Neil Conway <neil@determined.ai>
Date: Sun, 2 Jun 2024 18:00:23 -0400
Subject: [PATCH v2 4/4] Optimize COPY TO in text format using SIMD

CopyAttributeOutText() does a byte-by-byte loop looking for field delimiters and
escape sequences. Vectorizing this loop using SIMD yields a significant speedup
for wide attributes, assuming that escape sequences are rare.

We don't attempt to apply this optimization when encoding_embeds_ascii is true,
because the bookkeeping required would be complicated.
---
 src/backend/commands/copyto.c | 275 ++++++++++++++++++----------------
 1 file changed, 149 insertions(+), 126 deletions(-)

diff --git a/src/backend/commands/copyto.c b/src/backend/commands/copyto.c
index 9114bb1c48..e676b4e888 100644
--- a/src/backend/commands/copyto.c
+++ b/src/backend/commands/copyto.c
@@ -970,6 +970,140 @@ CopyOneRowTo(CopyToState cstate, TupleTableSlot *slot)
 	MemoryContextSwitchTo(oldcontext);
 }
 
+static void
+EmitTextCharacter(CopyToState cstate, char c)
+{
+	char	delimc = cstate->opts.delim[0];
+
+	if ((unsigned char) c < (unsigned char) 0x20)
+	{
+		/*
+		 * \r and \n must be escaped; we choose to escape several other common
+		 * control characters for the sake of tradition. We prefer to dump
+		 * these using the C-like notation, rather than a backslash and the
+		 * literal character, because it makes the dump file a bit more proof
+		 * against Microsoftish data mangling.
+		 */
+		switch (c)
+		{
+			case '\b':
+				c = 'b';
+				break;
+			case '\f':
+				c = 'f';
+				break;
+			case '\n':
+				c = 'n';
+				break;
+			case '\r':
+				c = 'r';
+				break;
+			case '\t':
+				c = 't';
+				break;
+			case '\v':
+				c = 'v';
+				break;
+			default:
+				/*
+				 * Record delimiter must be escaped, even if it is a control
+				 * character. Other control characters can be emitted as-is.
+				 */
+				if (c != delimc)
+				{
+					CopySendChar(cstate, c);
+					return;
+				}
+		}
+
+		CopySendChar(cstate, '\\');
+		CopySendChar(cstate, c);
+	}
+	else if (c == '\\' || c == delimc)
+	{
+		CopySendChar(cstate, '\\');
+		CopySendChar(cstate, c);
+	}
+	else
+	{
+		CopySendChar(cstate, c);
+	}
+}
+
+/*
+ * Send text representation of one attribute, with conversion and escaping.
+ * This variant is vectorized using SIMD instructions.  This is significantly
+ * faster for wide attributes, assuming that control characters are rare.
+ *
+ * This variant assumes that encoding_embeds_ascii is false.  This simplifies
+ * the implementation because we can look at arbitrary-sized chunks of bytes,
+ * without needing to go through the pg_encoding_mblen() machinery to ensure
+ * that multibyte characters don't cross chunk boundaries.  In principle we
+ * could combine vectorization with such encodings, but the bookkeeping
+ * required would be complicated.
+ */
+static void
+CopyAttributeOutTextVector(CopyToState cstate, const char *ptr)
+{
+	int			i;
+	int			len;
+	int			vlen;
+	int			start_idx;
+	Vector8		chunk;
+	char		delimc = cstate->opts.delim[0];
+
+	len = strlen(ptr);
+	vlen = len & (int) (~(sizeof(Vector8) - 1));
+	start_idx = 0;
+
+	for (i = 0; i < vlen; i += sizeof(Vector8))
+	{
+		vector8_load(&chunk, (const uint8 *) &ptr[i]);
+
+		/*
+		 * Check if the chunk contains any field delimiters or escape
+		 * sequences.  If so, switch to byte-by-byte processing.
+		 */
+		if (vector8_has_le(chunk, (unsigned char) 0x01f) ||
+			vector8_has(chunk, (unsigned char) '\\') ||
+			vector8_has(chunk, (unsigned char) delimc))
+		{
+			if (i > start_idx)
+			{
+				CopySendData(cstate, ptr + start_idx, i - start_idx);
+				start_idx = i;
+			}
+
+			for (int j = i; j < (i + sizeof(Vector8)); j++)
+			{
+				EmitTextCharacter(cstate, ptr[j]);
+				start_idx++;
+			}
+		}
+	}
+
+	/* Process the tail of the string */
+	for (; i < len; i++)
+	{
+		char c = ptr[i];
+
+		if ((unsigned char) c < (unsigned char) 0x20 ||
+			c == '\\' || c == delimc)
+		{
+			if (i > start_idx)
+			{
+				CopySendData(cstate, ptr + start_idx, i - start_idx);
+				start_idx = i;
+			}
+			EmitTextCharacter(cstate, c);
+			start_idx++;
+		}
+	}
+
+	if (i > start_idx)
+		CopySendData(cstate, ptr + start_idx, i - start_idx);
+}
+
 #define DUMPSOFAR() \
 	do { \
 		if (ptr > start) \
@@ -992,137 +1126,26 @@ CopyAttributeOutText(CopyToState cstate, const char *string)
 	else
 		ptr = string;
 
-	/*
-	 * We have to grovel through the string searching for control characters
-	 * and instances of the delimiter character.  In most cases, though, these
-	 * are infrequent.  To avoid overhead from calling CopySendData once per
-	 * character, we dump out all characters between escaped characters in a
-	 * single call.  The loop invariant is that the data from "start" to "ptr"
-	 * can be sent literally, but hasn't yet been.
-	 *
-	 * We can skip pg_encoding_mblen() overhead when encoding is safe, because
-	 * in valid backend encodings, extra bytes of a multibyte character never
-	 * look like ASCII.  This loop is sufficiently performance-critical that
-	 * it's worth making two copies of it to get the IS_HIGHBIT_SET() test out
-	 * of the normal safe-encoding path.
-	 */
-	if (cstate->encoding_embeds_ascii)
+	if (!cstate->encoding_embeds_ascii)
 	{
-		start = ptr;
-		while ((c = *ptr) != '\0')
-		{
-			if ((unsigned char) c < (unsigned char) 0x20)
-			{
-				/*
-				 * \r and \n must be escaped, the others are traditional. We
-				 * prefer to dump these using the C-like notation, rather than
-				 * a backslash and the literal character, because it makes the
-				 * dump file a bit more proof against Microsoftish data
-				 * mangling.
-				 */
-				switch (c)
-				{
-					case '\b':
-						c = 'b';
-						break;
-					case '\f':
-						c = 'f';
-						break;
-					case '\n':
-						c = 'n';
-						break;
-					case '\r':
-						c = 'r';
-						break;
-					case '\t':
-						c = 't';
-						break;
-					case '\v':
-						c = 'v';
-						break;
-					default:
-						/* If it's the delimiter, must backslash it */
-						if (c == delimc)
-							break;
-						/* All ASCII control chars are length 1 */
-						ptr++;
-						continue;	/* fall to end of loop */
-				}
-				/* if we get here, we need to convert the control char */
-				DUMPSOFAR();
-				CopySendChar(cstate, '\\');
-				CopySendChar(cstate, c);
-				start = ++ptr;	/* do not include char in next run */
-			}
-			else if (c == '\\' || c == delimc)
-			{
-				DUMPSOFAR();
-				CopySendChar(cstate, '\\');
-				start = ptr++;	/* we include char in next run */
-			}
-			else if (IS_HIGHBIT_SET(c))
-				ptr += pg_encoding_mblen(cstate->file_encoding, ptr);
-			else
-				ptr++;
-		}
+		CopyAttributeOutTextVector(cstate, ptr);
+		return;
 	}
-	else
+
+	start = ptr;
+	while ((c = *ptr) != '\0')
 	{
-		start = ptr;
-		while ((c = *ptr) != '\0')
+		if ((unsigned char) c < (unsigned char) 0x20 ||
+			c == '\\' || c == delimc)
 		{
-			if ((unsigned char) c < (unsigned char) 0x20)
-			{
-				/*
-				 * \r and \n must be escaped, the others are traditional. We
-				 * prefer to dump these using the C-like notation, rather than
-				 * a backslash and the literal character, because it makes the
-				 * dump file a bit more proof against Microsoftish data
-				 * mangling.
-				 */
-				switch (c)
-				{
-					case '\b':
-						c = 'b';
-						break;
-					case '\f':
-						c = 'f';
-						break;
-					case '\n':
-						c = 'n';
-						break;
-					case '\r':
-						c = 'r';
-						break;
-					case '\t':
-						c = 't';
-						break;
-					case '\v':
-						c = 'v';
-						break;
-					default:
-						/* If it's the delimiter, must backslash it */
-						if (c == delimc)
-							break;
-						/* All ASCII control chars are length 1 */
-						ptr++;
-						continue;	/* fall to end of loop */
-				}
-				/* if we get here, we need to convert the control char */
-				DUMPSOFAR();
-				CopySendChar(cstate, '\\');
-				CopySendChar(cstate, c);
-				start = ++ptr;	/* do not include char in next run */
-			}
-			else if (c == '\\' || c == delimc)
-			{
-				DUMPSOFAR();
-				CopySendChar(cstate, '\\');
-				start = ptr++;	/* we include char in next run */
-			}
-			else
-				ptr++;
+			DUMPSOFAR();
+			EmitTextCharacter(cstate, c);
+			start = ++ptr;
 		}
+		else if (IS_HIGHBIT_SET(c))
+			ptr += pg_encoding_mblen(cstate->file_encoding, ptr);
+		else
+			ptr++;
 	}
 
 	DUMPSOFAR();
-- 
2.39.3 (Apple Git-146)

From 2971ed42796b5e79b8ffc0dd84b8474874fb82e8 Mon Sep 17 00:00:00 2001
From: Neil Conway <neil@determined.ai>
Date: Sun, 2 Jun 2024 18:00:23 -0400
Subject: [PATCH v4 5/6] Optimize COPY TO in text format using SIMD

CopyAttributeOutText() does a byte-by-byte loop looking for field delimiters and
escape sequences. Vectorizing this loop using SIMD yields a significant speedup
for wide attributes, assuming that escape sequences are rare.

We don't attempt to apply this optimization when encoding_embeds_ascii is true,
because the bookkeeping required would be complicated.
---
 src/backend/commands/copyto.c | 280 +++++++++++++++++++---------------
 1 file changed, 154 insertions(+), 126 deletions(-)

diff --git a/src/backend/commands/copyto.c b/src/backend/commands/copyto.c
index 9114bb1c48..2453aa08df 100644
--- a/src/backend/commands/copyto.c
+++ b/src/backend/commands/copyto.c
@@ -970,6 +970,145 @@ CopyOneRowTo(CopyToState cstate, TupleTableSlot *slot)
 	MemoryContextSwitchTo(oldcontext);
 }
 
+static void
+EmitTextCharacter(CopyToState cstate, char c)
+{
+	char	delimc = cstate->opts.delim[0];
+
+	if ((unsigned char) c < (unsigned char) 0x20)
+	{
+		/*
+		 * \r and \n must be escaped; we choose to escape several other common
+		 * control characters for the sake of tradition. We prefer to dump
+		 * these using the C-like notation, rather than a backslash and the
+		 * literal character, because it makes the dump file a bit more proof
+		 * against Microsoftish data mangling.
+		 */
+		switch (c)
+		{
+			case '\b':
+				c = 'b';
+				break;
+			case '\f':
+				c = 'f';
+				break;
+			case '\n':
+				c = 'n';
+				break;
+			case '\r':
+				c = 'r';
+				break;
+			case '\t':
+				c = 't';
+				break;
+			case '\v':
+				c = 'v';
+				break;
+			default:
+				/*
+				 * Record delimiter must be escaped, even if it is a control
+				 * character. Other control characters can be emitted as-is.
+				 */
+				if (c != delimc)
+				{
+					CopySendChar(cstate, c);
+					return;
+				}
+		}
+
+		CopySendChar(cstate, '\\');
+		CopySendChar(cstate, c);
+	}
+	else if (c == '\\' || c == delimc)
+	{
+		CopySendChar(cstate, '\\');
+		CopySendChar(cstate, c);
+	}
+	else
+	{
+		CopySendChar(cstate, c);
+	}
+}
+
+/*
+ * Send text representation of one attribute, with conversion and escaping.
+ * This variant is vectorized using SIMD instructions.  This is significantly
+ * faster for wide attributes, assuming that control characters are rare.
+ *
+ * This variant assumes that encoding_embeds_ascii is false.  This simplifies
+ * the implementation because we can look at arbitrary-sized chunks of bytes,
+ * without needing to go through the pg_encoding_mblen() machinery to ensure
+ * that multibyte characters don't cross chunk boundaries.  In principle we
+ * could combine vectorization with such encodings, but the bookkeeping
+ * required would be complicated.
+ */
+static void
+CopyAttributeOutTextVector(CopyToState cstate, const char *ptr)
+{
+	int			i;
+	int			len;
+	int			vlen;
+	int			start_idx;
+	Vector8		chunk;
+	char		delimc = cstate->opts.delim[0];
+
+	len = strlen(ptr);
+	vlen = len & (int) (~(sizeof(Vector8) - 1));
+	start_idx = 0;
+
+	for (i = 0; i < vlen; i += sizeof(Vector8))
+	{
+		vector8_load(&chunk, (const uint8 *) &ptr[i]);
+
+		/*
+		 * Check if the chunk contains any field delimiters or escape
+		 * sequences.  If so, switch to byte-by-byte processing.
+		 */
+		if (vector8_has_le(chunk, (unsigned char) 0x1f) ||
+			vector8_has(chunk, (unsigned char) '\\') ||
+			vector8_has(chunk, (unsigned char) delimc))
+		{
+			for (int j = i; j < (i + sizeof(Vector8)); j++)
+			{
+				char c = ptr[j];
+
+				if ((unsigned char) c <= (unsigned char) 0x1f ||
+					c == '\\' || c == delimc)
+				{
+					if (j > start_idx)
+					{
+						CopySendData(cstate, ptr + start_idx, j - start_idx);
+						start_idx = j;
+					}
+					EmitTextCharacter(cstate, c);
+					start_idx++;
+				}
+			}
+		}
+	}
+
+	/* Process the tail of the string */
+	for (; i < len; i++)
+	{
+		char c = ptr[i];
+
+		if ((unsigned char) c <= (unsigned char) 0x1f ||
+			c == '\\' || c == delimc)
+		{
+			if (i > start_idx)
+			{
+				CopySendData(cstate, ptr + start_idx, i - start_idx);
+				start_idx = i;
+			}
+			EmitTextCharacter(cstate, c);
+			start_idx++;
+		}
+	}
+
+	if (i > start_idx)
+		CopySendData(cstate, ptr + start_idx, i - start_idx);
+}
+
 #define DUMPSOFAR() \
 	do { \
 		if (ptr > start) \
@@ -992,137 +1131,26 @@ CopyAttributeOutText(CopyToState cstate, const char *string)
 	else
 		ptr = string;
 
-	/*
-	 * We have to grovel through the string searching for control characters
-	 * and instances of the delimiter character.  In most cases, though, these
-	 * are infrequent.  To avoid overhead from calling CopySendData once per
-	 * character, we dump out all characters between escaped characters in a
-	 * single call.  The loop invariant is that the data from "start" to "ptr"
-	 * can be sent literally, but hasn't yet been.
-	 *
-	 * We can skip pg_encoding_mblen() overhead when encoding is safe, because
-	 * in valid backend encodings, extra bytes of a multibyte character never
-	 * look like ASCII.  This loop is sufficiently performance-critical that
-	 * it's worth making two copies of it to get the IS_HIGHBIT_SET() test out
-	 * of the normal safe-encoding path.
-	 */
-	if (cstate->encoding_embeds_ascii)
+	if (!cstate->encoding_embeds_ascii)
 	{
-		start = ptr;
-		while ((c = *ptr) != '\0')
-		{
-			if ((unsigned char) c < (unsigned char) 0x20)
-			{
-				/*
-				 * \r and \n must be escaped, the others are traditional. We
-				 * prefer to dump these using the C-like notation, rather than
-				 * a backslash and the literal character, because it makes the
-				 * dump file a bit more proof against Microsoftish data
-				 * mangling.
-				 */
-				switch (c)
-				{
-					case '\b':
-						c = 'b';
-						break;
-					case '\f':
-						c = 'f';
-						break;
-					case '\n':
-						c = 'n';
-						break;
-					case '\r':
-						c = 'r';
-						break;
-					case '\t':
-						c = 't';
-						break;
-					case '\v':
-						c = 'v';
-						break;
-					default:
-						/* If it's the delimiter, must backslash it */
-						if (c == delimc)
-							break;
-						/* All ASCII control chars are length 1 */
-						ptr++;
-						continue;	/* fall to end of loop */
-				}
-				/* if we get here, we need to convert the control char */
-				DUMPSOFAR();
-				CopySendChar(cstate, '\\');
-				CopySendChar(cstate, c);
-				start = ++ptr;	/* do not include char in next run */
-			}
-			else if (c == '\\' || c == delimc)
-			{
-				DUMPSOFAR();
-				CopySendChar(cstate, '\\');
-				start = ptr++;	/* we include char in next run */
-			}
-			else if (IS_HIGHBIT_SET(c))
-				ptr += pg_encoding_mblen(cstate->file_encoding, ptr);
-			else
-				ptr++;
-		}
+		CopyAttributeOutTextVector(cstate, ptr);
+		return;
 	}
-	else
+
+	start = ptr;
+	while ((c = *ptr) != '\0')
 	{
-		start = ptr;
-		while ((c = *ptr) != '\0')
+		if ((unsigned char) c < (unsigned char) 0x20 ||
+			c == '\\' || c == delimc)
 		{
-			if ((unsigned char) c < (unsigned char) 0x20)
-			{
-				/*
-				 * \r and \n must be escaped, the others are traditional. We
-				 * prefer to dump these using the C-like notation, rather than
-				 * a backslash and the literal character, because it makes the
-				 * dump file a bit more proof against Microsoftish data
-				 * mangling.
-				 */
-				switch (c)
-				{
-					case '\b':
-						c = 'b';
-						break;
-					case '\f':
-						c = 'f';
-						break;
-					case '\n':
-						c = 'n';
-						break;
-					case '\r':
-						c = 'r';
-						break;
-					case '\t':
-						c = 't';
-						break;
-					case '\v':
-						c = 'v';
-						break;
-					default:
-						/* If it's the delimiter, must backslash it */
-						if (c == delimc)
-							break;
-						/* All ASCII control chars are length 1 */
-						ptr++;
-						continue;	/* fall to end of loop */
-				}
-				/* if we get here, we need to convert the control char */
-				DUMPSOFAR();
-				CopySendChar(cstate, '\\');
-				CopySendChar(cstate, c);
-				start = ++ptr;	/* do not include char in next run */
-			}
-			else if (c == '\\' || c == delimc)
-			{
-				DUMPSOFAR();
-				CopySendChar(cstate, '\\');
-				start = ptr++;	/* we include char in next run */
-			}
-			else
-				ptr++;
+			DUMPSOFAR();
+			EmitTextCharacter(cstate, c);
+			start = ++ptr;
 		}
+		else if (IS_HIGHBIT_SET(c))
+			ptr += pg_encoding_mblen(cstate->file_encoding, ptr);
+		else
+			ptr++;
 	}
 
 	DUMPSOFAR();
-- 
2.39.3 (Apple Git-146)

From 3292dcda3d7a307af0fc09d8eb276cfeb1911058 Mon Sep 17 00:00:00 2001
From: Neil Conway <neil.conway@gmail.com>
Date: Fri, 7 Jun 2024 08:40:06 -0400
Subject: [PATCH v4 3/6] Cosmetic code cleanup for CopyReadLineText()

Use a consistent naming prefix for variables relating to the COPY input buffer.
---
 src/backend/commands/copyfromparse.c | 30 ++++++++++++++--------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/backend/commands/copyfromparse.c b/src/backend/commands/copyfromparse.c
index 7efcb89159..067a33f924 100644
--- a/src/backend/commands/copyfromparse.c
+++ b/src/backend/commands/copyfromparse.c
@@ -98,7 +98,7 @@
 #define IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(extralen) \
 if (1) \
 { \
-	if (input_buf_ptr + (extralen) >= copy_buf_len && !hit_eof) \
+	if (input_buf_ptr + (extralen) >= input_buf_len && !hit_eof) \
 	{ \
 		input_buf_ptr = prev_raw_ptr; /* undo fetch */ \
 		need_data = true; \
@@ -110,10 +110,10 @@ if (1) \
 #define IF_NEED_REFILL_AND_EOF_BREAK(extralen) \
 if (1) \
 { \
-	if (input_buf_ptr + (extralen) >= copy_buf_len && hit_eof) \
+	if (input_buf_ptr + (extralen) >= input_buf_len && hit_eof) \
 	{ \
 		if (extralen) \
-			input_buf_ptr = copy_buf_len; /* consume the partial character */ \
+			input_buf_ptr = input_buf_len; /* consume the partial character */ \
 		/* backslash just before EOF, treat as data char */ \
 		result = true; \
 		break; \
@@ -130,7 +130,7 @@ if (1) \
 	if (input_buf_ptr > cstate->input_buf_index) \
 	{ \
 		appendBinaryStringInfo(&cstate->line_buf, \
-							 cstate->input_buf + cstate->input_buf_index, \
+							   cstate->input_buf + cstate->input_buf_index, \
 							   input_buf_ptr - cstate->input_buf_index); \
 		cstate->input_buf_index = input_buf_ptr; \
 	} \
@@ -1174,9 +1174,9 @@ CopyReadLine(CopyFromState cstate)
 static bool
 CopyReadLineText(CopyFromState cstate)
 {
-	char	   *copy_input_buf;
+	char	   *input_buf;
 	int			input_buf_ptr;
-	int			copy_buf_len;
+	int			input_buf_len;
 	bool		need_data = false;
 	bool		hit_eof = false;
 	bool		result = false;
@@ -1222,9 +1222,9 @@ CopyReadLineText(CopyFromState cstate)
 	 * For a little extra speed within the loop, we copy input_buf and
 	 * input_buf_len into local variables.
 	 */
-	copy_input_buf = cstate->input_buf;
+	input_buf = cstate->input_buf;
 	input_buf_ptr = cstate->input_buf_index;
-	copy_buf_len = cstate->input_buf_len;
+	input_buf_len = cstate->input_buf_len;
 
 	for (;;)
 	{
@@ -1239,7 +1239,7 @@ CopyReadLineText(CopyFromState cstate)
 		 * unsafe with the old v2 COPY protocol, but we don't support that
 		 * anymore.
 		 */
-		if (input_buf_ptr >= copy_buf_len || need_data)
+		if (input_buf_ptr >= input_buf_len || need_data)
 		{
 			REFILL_LINEBUF;
 
@@ -1247,7 +1247,7 @@ CopyReadLineText(CopyFromState cstate)
 			/* update our local variables */
 			hit_eof = cstate->input_reached_eof;
 			input_buf_ptr = cstate->input_buf_index;
-			copy_buf_len = cstate->input_buf_len;
+			input_buf_len = cstate->input_buf_len;
 
 			/*
 			 * If we are completely out of data, break out of the loop,
@@ -1263,7 +1263,7 @@ CopyReadLineText(CopyFromState cstate)
 
 		/* OK to fetch a character */
 		prev_raw_ptr = input_buf_ptr;
-		c = copy_input_buf[input_buf_ptr++];
+		c = input_buf[input_buf_ptr++];
 
 		if (cstate->opts.csv_mode)
 		{
@@ -1319,7 +1319,7 @@ CopyReadLineText(CopyFromState cstate)
 				IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
 
 				/* get next char */
-				c = copy_input_buf[input_buf_ptr];
+				c = input_buf[input_buf_ptr];
 
 				if (c == '\n')
 				{
@@ -1393,7 +1393,7 @@ CopyReadLineText(CopyFromState cstate)
 			 * through and continue processing.
 			 * -----
 			 */
-			c2 = copy_input_buf[input_buf_ptr];
+			c2 = input_buf[input_buf_ptr];
 
 			if (c2 == '.')
 			{
@@ -1409,7 +1409,7 @@ CopyReadLineText(CopyFromState cstate)
 					/* Get the next character */
 					IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
 					/* if hit_eof, c2 will become '\0' */
-					c2 = copy_input_buf[input_buf_ptr++];
+					c2 = input_buf[input_buf_ptr++];
 
 					if (c2 == '\n')
 					{
@@ -1434,7 +1434,7 @@ CopyReadLineText(CopyFromState cstate)
 				/* Get the next character */
 				IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
 				/* if hit_eof, c2 will become '\0' */
-				c2 = copy_input_buf[input_buf_ptr++];
+				c2 = input_buf[input_buf_ptr++];
 
 				if (c2 != '\r' && c2 != '\n')
 				{
-- 
2.39.3 (Apple Git-146)

From f3e91bbf9a587fa91762aa3b8ba2f4b5838477b8 Mon Sep 17 00:00:00 2001
From: Neil Conway <neil@determined.ai>
Date: Sun, 2 Jun 2024 14:00:58 -0400
Subject: [PATCH v4 4/6] Optimize COPY TO in CSV format using SIMD

CopyAttributeOutCSV() does one or two byte-by-byte loops over the text of each
attribute, depending on whether quotation is required. Implementing this loops
using SIMD yields a significant speedup for long attribute values. For short
attribute values, performance is roughly unchanged.

We don't attempt to apply this optimization encoding_embeds_ascii is true,
because the required bookkeeping would be complicated.
---
 src/backend/commands/copyto.c | 152 +++++++++++++++++++++++++++++++++-
 1 file changed, 149 insertions(+), 3 deletions(-)

diff --git a/src/backend/commands/copyto.c b/src/backend/commands/copyto.c
index cd2d7bb217..9114bb1c48 100644
--- a/src/backend/commands/copyto.c
+++ b/src/backend/commands/copyto.c
@@ -29,6 +29,7 @@
 #include "mb/pg_wchar.h"
 #include "miscadmin.h"
 #include "pgstat.h"
+#include "port/simd.h"
 #include "storage/fd.h"
 #include "tcop/tcopprot.h"
 #include "utils/lsyscache.h"
@@ -1127,6 +1128,144 @@ CopyAttributeOutText(CopyToState cstate, const char *string)
 	DUMPSOFAR();
 }
 
+/*
+ * Send text representation of one attribute, with conversion and CSV-style
+ * escaping.  This is significantly faster for wide attributes, assuming that
+ * control characters are rare.
+ *
+ * This variant assumes that encoding_embeds_ascii is false.  This simplifies
+ * the implementation because we can look at arbitrary-sized chunks of bytes,
+ * without needing to go through the pg_encoding_mblen() machinery to ensure
+ * that multibyte characters don't cross chunk boundaries.  In principle we
+ * could combine vectorization with such encodings, but the bookkeeping
+ * required would be complicated.
+ */
+static void
+CopyAttributeOutCSVVector(CopyToState cstate, const char *ptr,
+						  bool use_quote)
+{
+	int			len;
+	int			vlen;
+	char		delimc = cstate->opts.delim[0];
+	char		quotec = cstate->opts.quote[0];
+	char		escapec = cstate->opts.escape[0];
+
+	len = strlen(ptr);
+	vlen = len & (int) (~(sizeof(Vector8) - 1));
+
+	/*
+	 * Make a preliminary pass to discover if it needs quoting
+	 */
+	if (!use_quote)
+	{
+		bool	single_attr = (list_length(cstate->attnumlist) == 1);
+
+		/*
+		 * Because '\.' can be a data value, quote it if it appears alone on a
+		 * line so it is not interpreted as the end-of-data marker.
+		 */
+		if (single_attr && strcmp(ptr, "\\.") == 0)
+			use_quote = true;
+		else
+		{
+			int		i;
+			Vector8 chunk;
+
+			for (i = 0; i < vlen; i += sizeof(Vector8))
+			{
+				vector8_load(&chunk, (const uint8 *) &ptr[i]);
+
+				if (vector8_has(chunk, (unsigned char) delimc) ||
+					vector8_has(chunk, (unsigned char) quotec) ||
+					vector8_has(chunk, (unsigned char) '\n') ||
+					vector8_has(chunk, (unsigned char) '\r'))
+				{
+					use_quote = true;
+					break;
+				}
+			}
+
+			/* Check the tail of the string */
+			if (!use_quote)
+			{
+				for (; i < len; i++)
+				{
+					char c = ptr[i];
+
+					if (c == delimc || c == quotec || c == '\n' || c == '\r')
+					{
+						use_quote = true;
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	if (use_quote)
+	{
+		int		i;
+		int		start_idx = 0;
+		Vector8 chunk;
+
+		CopySendChar(cstate, quotec);
+
+		for (i = 0; i < vlen; i += sizeof(Vector8))
+		{
+			vector8_load(&chunk, (const uint8 *) &ptr[i]);
+
+			if (vector8_has(chunk, (unsigned char) delimc) ||
+				vector8_has(chunk, (unsigned char) quotec))
+			{
+				/*
+				 * This chunk has one or more characters that require
+				 * escaping, so switch to byte-at-a-time processing
+				 */
+				for (int j = i; j < (i + sizeof(Vector8)); j++)
+				{
+					char c = ptr[j];
+
+					if (c == quotec || c == escapec)
+					{
+						if (j > start_idx)
+							CopySendData(cstate, ptr + start_idx, j - start_idx);
+
+						CopySendChar(cstate, escapec);
+						start_idx = j;
+					}
+				}
+			}
+		}
+
+		/* Process the tail of the string */
+		for (; i < len; i++)
+		{
+			char c = ptr[i];
+
+			if (c == quotec || c == escapec)
+			{
+				if (i > start_idx)
+					CopySendData(cstate, ptr + start_idx, i - start_idx);
+
+				CopySendChar(cstate, escapec);
+				start_idx = i;
+			}
+		}
+
+		/* Send any remaining text */
+		if (start_idx < len)
+			CopySendData(cstate, ptr + start_idx, len - start_idx);
+
+		CopySendChar(cstate, quotec);
+	}
+	else
+	{
+		/* If it doesn't need quoting, we can just dump it as-is */
+		CopySendData(cstate, ptr, len);
+	}
+}
+
+
 /*
  * Send text representation of one attribute, with conversion and
  * CSV-style escaping
@@ -1141,7 +1280,6 @@ CopyAttributeOutCSV(CopyToState cstate, const char *string,
 	char		delimc = cstate->opts.delim[0];
 	char		quotec = cstate->opts.quote[0];
 	char		escapec = cstate->opts.escape[0];
-	bool		single_attr = (list_length(cstate->attnumlist) == 1);
 
 	/* force quoting if it matches null_print (before conversion!) */
 	if (!use_quote && strcmp(string, cstate->opts.null_print) == 0)
@@ -1152,11 +1290,19 @@ CopyAttributeOutCSV(CopyToState cstate, const char *string,
 	else
 		ptr = string;
 
+	if (!cstate->encoding_embeds_ascii)
+	{
+		CopyAttributeOutCSVVector(cstate, ptr, use_quote);
+		return;
+	}
+
 	/*
 	 * Make a preliminary pass to discover if it needs quoting
 	 */
 	if (!use_quote)
 	{
+		bool	single_attr = (list_length(cstate->attnumlist) == 1);
+
 		/*
 		 * Because '\.' can be a data value, quote it if it appears alone on a
 		 * line so it is not interpreted as the end-of-data marker.
@@ -1174,7 +1320,7 @@ CopyAttributeOutCSV(CopyToState cstate, const char *string,
 					use_quote = true;
 					break;
 				}
-				if (IS_HIGHBIT_SET(c) && cstate->encoding_embeds_ascii)
+				if (IS_HIGHBIT_SET(c))
 					tptr += pg_encoding_mblen(cstate->file_encoding, tptr);
 				else
 					tptr++;
@@ -1198,7 +1344,7 @@ CopyAttributeOutCSV(CopyToState cstate, const char *string,
 				CopySendChar(cstate, escapec);
 				start = ptr;	/* we include char in next run */
 			}
-			if (IS_HIGHBIT_SET(c) && cstate->encoding_embeds_ascii)
+			if (IS_HIGHBIT_SET(c))
 				ptr += pg_encoding_mblen(cstate->file_encoding, ptr);
 			else
 				ptr++;
-- 
2.39.3 (Apple Git-146)

From 39650379c974d64631960510be12d88595249641 Mon Sep 17 00:00:00 2001
From: Neil Conway <neil@determined.ai>
Date: Sun, 2 Jun 2024 18:50:30 -0400
Subject: [PATCH v4 2/6] Improve COPY test coverage for handling of control
 characters

---
 src/test/regress/expected/copy2.out | 38 +++++++++++++++++++++++++++++
 src/test/regress/sql/copy2.sql      | 25 +++++++++++++++++++
 2 files changed, 63 insertions(+)

diff --git a/src/test/regress/expected/copy2.out b/src/test/regress/expected/copy2.out
index 931542f268..be654daf4a 100644
--- a/src/test/regress/expected/copy2.out
+++ b/src/test/regress/expected/copy2.out
@@ -905,3 +905,41 @@ truncate copy_default;
 -- DEFAULT cannot be used in COPY TO
 copy (select 1 as test) TO stdout with (default '\D');
 ERROR:  COPY DEFAULT only available using COPY FROM
+-- Test handling of control characters
+create temp table copy_ctl (a text, b text);
+copy copy_ctl from stdin;
+copy copy_ctl to stdout;
+abc	def
+\n	def
+abc	\n
+\t	def
+abc	\t
+ab\b	\bdef
+a\vbc	def\v
+\f\f\f	g\fg
+\f	def
+abc	
+	def
+abc	
+\\	\n\t\\
+9	9999
+S4	j
+copy copy_ctl to stdout with (format csv);
+abc,def
+"
+",def
+abc,"
+"
+	,def
+abc,	
+ab,def
+abc,def
+,gg
+,def
+abc,
+,def
+abc,
+\,"
+	\"
+9,9999
+S4,j
diff --git a/src/test/regress/sql/copy2.sql b/src/test/regress/sql/copy2.sql
index 8b14962194..e8d495e024 100644
--- a/src/test/regress/sql/copy2.sql
+++ b/src/test/regress/sql/copy2.sql
@@ -676,3 +676,28 @@ truncate copy_default;
 
 -- DEFAULT cannot be used in COPY TO
 copy (select 1 as test) TO stdout with (default '\D');
+
+-- Test handling of control characters
+create temp table copy_ctl (a text, b text);
+
+copy copy_ctl from stdin;
+abc	def
+\n	def
+abc	\n
+\t	def
+abc	\t
+ab\b	\bdef
+a\vbc	def\v
+\f\f\f	g\fg
+\x0c	def
+abc	\x6
+\6	def
+abc	\017
+\\	\
+\	\\
+\9	\9999
+\1234	\j
+\.
+
+copy copy_ctl to stdout;
+copy copy_ctl to stdout with (format csv);
-- 
2.39.3 (Apple Git-146)

From 7c8742685dee201f4fc182143dbcc6587f90a8f9 Mon Sep 17 00:00:00 2001
From: Neil Conway <neil@determined.ai>
Date: Sun, 2 Jun 2024 12:01:48 -0400
Subject: [PATCH v4 1/6] Adjust misleading comment placement

---
 src/backend/commands/copyto.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/backend/commands/copyto.c b/src/backend/commands/copyto.c
index ae8b2e36d7..cd2d7bb217 100644
--- a/src/backend/commands/copyto.c
+++ b/src/backend/commands/copyto.c
@@ -969,15 +969,15 @@ CopyOneRowTo(CopyToState cstate, TupleTableSlot *slot)
 	MemoryContextSwitchTo(oldcontext);
 }
 
-/*
- * Send text representation of one attribute, with conversion and escaping
- */
 #define DUMPSOFAR() \
 	do { \
 		if (ptr > start) \
 			CopySendData(cstate, start, ptr - start); \
 	} while (0)
 
+/*
+ * Send text representation of one attribute, with conversion and escaping
+ */
 static void
 CopyAttributeOutText(CopyToState cstate, const char *string)
 {
-- 
2.39.3 (Apple Git-146)

From 3da65874d99d0b7e5fd7c918f8c31d3ebcaef338 Mon Sep 17 00:00:00 2001
From: Neil Conway <neil.conway@gmail.com>
Date: Fri, 7 Jun 2024 11:25:43 -0400
Subject: [PATCH v4 6/6] Optimize COPY FROM using SIMD

CopyReadLineText() scans the COPY input buffer looking for newlines and escape
sequences (as well as quotes in CSV mode). We can use SIMD instructions to
efficiently skip chunks of text that don't contain any interesting
characters. This yields a significant performance improvement for wide rows
(many attributes and/or wide attribute values).
---
 src/backend/commands/copyfromparse.c | 36 ++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/src/backend/commands/copyfromparse.c b/src/backend/commands/copyfromparse.c
index 067a33f924..f1f2415bde 100644
--- a/src/backend/commands/copyfromparse.c
+++ b/src/backend/commands/copyfromparse.c
@@ -73,6 +73,7 @@
 #include "nodes/miscnodes.h"
 #include "pgstat.h"
 #include "port/pg_bswap.h"
+#include "port/simd.h"
 #include "utils/builtins.h"
 #include "utils/rel.h"
 
@@ -1180,6 +1181,7 @@ CopyReadLineText(CopyFromState cstate)
 	bool		need_data = false;
 	bool		hit_eof = false;
 	bool		result = false;
+	Vector8		chunk;
 
 	/* CSV variables */
 	bool		first_char_in_line = true;
@@ -1261,6 +1263,40 @@ CopyReadLineText(CopyFromState cstate)
 			need_data = false;
 		}
 
+		/*
+		 * If there is enough data available, use SIMD to check for special
+		 * characters. This allows us to efficiently skip large chunks of
+		 * text, in the common case that newlines and control characters are
+		 * relatively rare.
+		 */
+		Assert(input_buf_ptr <= cstate->input_buf_len);
+		if (cstate->input_buf_len - input_buf_ptr >= sizeof(Vector8))
+		{
+			vector8_load(&chunk, (const uint8 *) &input_buf[input_buf_ptr]);
+
+			if (!(vector8_has(chunk, (unsigned char) '\\') ||
+				  vector8_has(chunk, (unsigned char) '\r') ||
+				  vector8_has(chunk, (unsigned char) '\n') ||
+				  (cstate->opts.csv_mode && vector8_has(
+					  chunk, (unsigned char) escapec)) ||
+				  (cstate->opts.csv_mode && vector8_has(
+					  chunk, (unsigned char) quotec))))
+			{
+				input_buf_ptr += sizeof(Vector8);
+				continue;
+			}
+
+			/*
+			 * Otherwise, proceed byte-by-byte. Note that on subsequent loop
+			 * iterations, because we will only advance input_buf_ptr by a few
+			 * bytes (usually only one), the SIMD checks above will often be
+			 * repeated on an overlapping range of bytes.
+			 *
+			 * TODO: check whether the bookkeeping required to avoid this is
+			 * worth the cost/complexity.
+			 */
+		}
+
 		/* OK to fetch a character */
 		prev_raw_ptr = input_buf_ptr;
 		c = input_buf[input_buf_ptr++];
-- 
2.39.3 (Apple Git-146)