raw output from copy

commit 60c6701fe5a91c41e9ed0db99676c8b1a27e85e3
Author: Pavel Stehule <pavel.stehule@gooddata.com>
Date:   Fri Apr 10 23:22:39 2015 +0200

    initial

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 92ff632..5701f8b 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -113,6 +113,7 @@ typedef struct CopyStateData
 	char	   *filename;		/* filename, or NULL for STDIN/STDOUT */
 	bool		is_program;		/* is 'filename' a program to popen? */
 	bool		binary;			/* binary format? */
+	bool		raw;			/* raw format - data only */
 	bool		oids;			/* include OIDs? */
 	bool		freeze;			/* freeze rows on loading? */
 	bool		csv_mode;		/* Comma Separated Value format? */
@@ -348,6 +349,13 @@ SendCopyBegin(CopyState cstate)
 		int16		format = (cstate->binary ? 1 : 0);
 		int			i;
 
+		if (cstate->binary)
+			format = 1;
+		else if (cstate->raw)
+			format = 2;
+		else
+			format = 0;
+
 		pq_beginmessage(&buf, 'H');
 		pq_sendbyte(&buf, format);		/* overall format */
 		pq_sendint(&buf, natts, 2);
@@ -359,7 +367,7 @@ SendCopyBegin(CopyState cstate)
 	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
 	{
 		/* old way */
-		if (cstate->binary)
+		if (cstate->binary || cstate->raw)
 			ereport(ERROR,
 					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 			errmsg("COPY BINARY is not supported to stdout or from stdin")));
@@ -371,7 +379,7 @@ SendCopyBegin(CopyState cstate)
 	else
 	{
 		/* very old way */
-		if (cstate->binary)
+		if (cstate->binary || cstate->raw)
 			ereport(ERROR,
 					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 			errmsg("COPY BINARY is not supported to stdout or from stdin")));
@@ -485,7 +493,7 @@ CopySendEndOfRow(CopyState cstate)
 	switch (cstate->copy_dest)
 	{
 		case COPY_FILE:
-			if (!cstate->binary)
+			if (!(cstate->binary || cstate->raw))
 			{
 				/* Default line termination depends on platform */
 #ifndef WIN32
@@ -543,7 +551,7 @@ CopySendEndOfRow(CopyState cstate)
 			break;
 		case COPY_NEW_FE:
 			/* The FE/BE protocol uses \n as newline for all platforms */
-			if (!cstate->binary)
+			if (!(cstate->binary || cstate->raw))
 				CopySendChar(cstate, '\n');
 
 			/* Dump the accumulated row as one CopyData message */
@@ -1005,6 +1013,8 @@ ProcessCopyOptions(CopyState cstate,
 				cstate->csv_mode = true;
 			else if (strcmp(fmt, "binary") == 0)
 				cstate->binary = true;
+			else if (strcmp(fmt, "raw") == 0)
+				cstate->raw = true;
 			else
 				ereport(ERROR,
 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
@@ -1808,6 +1818,10 @@ CopyTo(CopyState cstate)
 	num_phys_attrs = tupDesc->natts;
 	cstate->null_print_client = cstate->null_print;		/* default */
 
+	/* don't allow more columns for raw format */
+	if (tupDesc->natts > 1)
+		elog(ERROR, "too much columns for RAW output");
+
 	/* We use fe_msgbuf as a per-row buffer regardless of copy_dest */
 	cstate->fe_msgbuf = makeStringInfo();
 
@@ -1819,7 +1833,7 @@ CopyTo(CopyState cstate)
 		Oid			out_func_oid;
 		bool		isvarlena;
 
-		if (cstate->binary)
+		if ((cstate->binary || cstate->raw))
 			getTypeBinaryOutputInfo(attr[attnum - 1]->atttypid,
 									&out_func_oid,
 									&isvarlena);
@@ -1858,7 +1872,7 @@ CopyTo(CopyState cstate)
 		tmp = 0;
 		CopySendInt32(cstate, tmp);
 	}
-	else
+	else if (!cstate->raw)
 	{
 		/*
 		 * For non-binary copy, we need to convert null_print to file
@@ -1970,7 +1984,7 @@ CopyOneRowTo(CopyState cstate, Oid tupleOid, Datum *values, bool *nulls)
 			CopySendInt32(cstate, tupleOid);
 		}
 	}
-	else
+	else if (!cstate->raw)
 	{
 		/* Text format has no per-tuple header, but send OID if wanted */
 		/* Assume digits don't need any quoting or encoding conversion */
@@ -1998,14 +2012,16 @@ CopyOneRowTo(CopyState cstate, Oid tupleOid, Datum *values, bool *nulls)
 
 		if (isnull)
 		{
-			if (!cstate->binary)
+			if (cstate->raw)
+				elog(ERROR, "cannot to push NULL in raw output");
+			else if (!cstate->binary)
 				CopySendString(cstate, cstate->null_print_client);
 			else
 				CopySendInt32(cstate, -1);
 		}
 		else
 		{
-			if (!cstate->binary)
+			if (!(cstate->binary || cstate->raw))
 			{
 				string = OutputFunctionCall(&out_functions[attnum - 1],
 											value);
diff --git a/src/interfaces/libpq/fe-protocol3.c b/src/interfaces/libpq/fe-protocol3.c
index a847f08..135c052 100644
--- a/src/interfaces/libpq/fe-protocol3.c
+++ b/src/interfaces/libpq/fe-protocol3.c
@@ -1352,6 +1352,8 @@ getCopyStart(PGconn *conn, ExecStatusType copytype)
 		 */
 		format = (int) ((int16) format);
 		result->attDescs[i].format = format;
+
+		conn->copy_raw_mode = format == 2;
 	}
 
 	/* Success! */
@@ -1544,13 +1546,38 @@ pqGetCopyData3(PGconn *conn, char **buffer, int async)
 								  libpq_gettext("out of memory\n"));
 				return -2;
 			}
-			memcpy(*buffer, &conn->inBuffer[conn->inCursor], msgLength);
-			(*buffer)[msgLength] = '\0';		/* Add terminating null */
 
-			/* Mark message consumed */
-			conn->inStart = conn->inCursor + msgLength;
+			if (!conn->copy_raw_mode)
+			{
+				memcpy(*buffer, &conn->inBuffer[conn->inCursor], msgLength);
+				(*buffer)[msgLength] = '\0';		/* Add terminating null */
 
-			return msgLength;
+				conn->inStart = conn->inCursor + msgLength;
+
+				return msgLength;
+			}
+			else
+			{
+				if (msgLength < 4)
+				{
+					printfPQExpBuffer(&conn->errorMessage,
+									  libpq_gettext("broken format\n"));
+					return -2;
+				}
+
+				/*
+				 * raw format is same as binary without addtional info. Every
+				 * binary data starts with length 4B
+				 */
+				memcpy(*buffer, &conn->inBuffer[conn->inCursor + 4], msgLength - 4);
+				(*buffer)[msgLength] = '\0';		/* Add terminating null */
+
+				conn->inStart = conn->inCursor + msgLength;
+
+				return msgLength - 4;
+			}
+
+			/* Mark message consumed */
 		}
 
 		/* Empty, so drop it and loop around for another */
diff --git a/src/interfaces/libpq/libpq-int.h b/src/interfaces/libpq/libpq-int.h
index 2175957..23bde61 100644
--- a/src/interfaces/libpq/libpq-int.h
+++ b/src/interfaces/libpq/libpq-int.h
@@ -421,6 +421,8 @@ struct pg_conn
 	PGresult   *result;			/* result being constructed */
 	PGresult   *next_result;	/* next result (used in single-row mode) */
 
+	bool		copy_raw_mode;		/* true, when one value is passed by copy protocol */
+
 	/* Assorted state for SSL, GSS, etc */
 
 #ifdef USE_SSL

commit 5599347d6b0b29a2674d465b3ff03164fce59810
Author: Pavel Stehule <pavel.stehule@gooddata.com>
Date:   Mon Jul 6 23:18:18 2015 +0200

    COPY FROM/TO (FORMAT RAW)

diff --git a/doc/src/sgml/ref/copy.sgml b/doc/src/sgml/ref/copy.sgml
index 2850b47..4b7b64d 100644
--- a/doc/src/sgml/ref/copy.sgml
+++ b/doc/src/sgml/ref/copy.sgml
@@ -190,7 +190,7 @@ COPY { <replaceable class="parameter">table_name</replaceable> [ ( <replaceable
       Selects the data format to be read or written:
       <literal>text</>,
       <literal>csv</> (Comma Separated Values),
-      or <literal>binary</>.
+      <literal>binary</> or <literal>raw</literal>.
       The default is <literal>text</>.
      </para>
     </listitem>
@@ -881,6 +881,23 @@ OIDs to be shown as null if that ever proves desirable.
     </para>
    </refsect3>
   </refsect2>
+
+  <refsect2>
+     <title>Raw Format</title>
+
+   <para>
+    The <literal>raw</literal> format option causes all data to be
+    stored/read as binary format rather than as text. It shares format
+    for data with <literal>binary</literal> format. This format doesn't
+    use any metadata - only row data in network byte order are exported
+    or imported.
+   </para>
+
+   <para>
+    Because this format doesn't support any delimiter, only one value
+    can be exported or imported. NULL values are not allowed.
+   </para>
+  </refsect2>
  </refsect1>
 
  <refsect1>
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 8904676..2ad7eb1 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -92,6 +92,11 @@ typedef enum EolType
  * it's faster to make useless comparisons to trailing bytes than it is to
  * invoke pg_encoding_mblen() to skip over them. encoding_embeds_ascii is TRUE
  * when we have to do it the hard way.
+ *
+ * COPY supports three modes: text, binary and raw. The text format is plain
+ * text multiline format with specified delimiter. The binary format holds
+ * metadata (numbers, sizes) and data. The raw format holds data only and
+ * only one non NULL value can be processed.
  */
 typedef struct CopyStateData
 {
@@ -113,6 +118,7 @@ typedef struct CopyStateData
 	char	   *filename;		/* filename, or NULL for STDIN/STDOUT */
 	bool		is_program;		/* is 'filename' a program to popen? */
 	bool		binary;			/* binary format? */
+	bool		raw;			/* required raw binary? */
 	bool		oids;			/* include OIDs? */
 	bool		freeze;			/* freeze rows on loading? */
 	bool		csv_mode;		/* Comma Separated Value format? */
@@ -202,6 +208,9 @@ typedef struct CopyStateData
 	char	   *raw_buf;
 	int			raw_buf_index;	/* next byte to process */
 	int			raw_buf_len;	/* total # of bytes stored */
+
+	/* field for RAW mode */
+	bool		row_processed;		/* true, when first row was processed */
 } CopyStateData;
 
 /* DestReceiver for COPY (SELECT) TO */
@@ -345,9 +354,16 @@ SendCopyBegin(CopyState cstate)
 		/* new way */
 		StringInfoData buf;
 		int			natts = list_length(cstate->attnumlist);
-		int16		format = (cstate->binary ? 1 : 0);
+		int16		format;
 		int			i;
 
+		if (cstate->raw)
+			format = 2;
+		else if (cstate->binary)
+			format = 1;
+		else
+			format = 0;
+
 		pq_beginmessage(&buf, 'H');
 		pq_sendbyte(&buf, format);		/* overall format */
 		pq_sendint(&buf, natts, 2);
@@ -359,7 +375,7 @@ SendCopyBegin(CopyState cstate)
 	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
 	{
 		/* old way */
-		if (cstate->binary)
+		if (cstate->binary && cstate->raw)
 			ereport(ERROR,
 					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 			errmsg("COPY BINARY is not supported to stdout or from stdin")));
@@ -371,7 +387,7 @@ SendCopyBegin(CopyState cstate)
 	else
 	{
 		/* very old way */
-		if (cstate->binary)
+		if (cstate->binary && cstate->raw)
 			ereport(ERROR,
 					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 			errmsg("COPY BINARY is not supported to stdout or from stdin")));
@@ -390,9 +406,16 @@ ReceiveCopyBegin(CopyState cstate)
 		/* new way */
 		StringInfoData buf;
 		int			natts = list_length(cstate->attnumlist);
-		int16		format = (cstate->binary ? 1 : 0);
+		int16		format;
 		int			i;
 
+		if (cstate->raw)
+			format = 2;
+		else if (cstate->binary)
+			format = 1;
+		else
+			format = 0;
+
 		pq_beginmessage(&buf, 'G');
 		pq_sendbyte(&buf, format);		/* overall format */
 		pq_sendint(&buf, natts, 2);
@@ -405,7 +428,7 @@ ReceiveCopyBegin(CopyState cstate)
 	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
 	{
 		/* old way */
-		if (cstate->binary)
+		if (cstate->binary || cstate->raw)
 			ereport(ERROR,
 					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 			errmsg("COPY BINARY is not supported to stdout or from stdin")));
@@ -417,7 +440,7 @@ ReceiveCopyBegin(CopyState cstate)
 	else
 	{
 		/* very old way */
-		if (cstate->binary)
+		if (cstate->binary || cstate->raw)
 			ereport(ERROR,
 					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 			errmsg("COPY BINARY is not supported to stdout or from stdin")));
@@ -485,7 +508,7 @@ CopySendEndOfRow(CopyState cstate)
 	switch (cstate->copy_dest)
 	{
 		case COPY_FILE:
-			if (!cstate->binary)
+			if (!cstate->binary && !cstate->raw)
 			{
 				/* Default line termination depends on platform */
 #ifndef WIN32
@@ -530,7 +553,7 @@ CopySendEndOfRow(CopyState cstate)
 			break;
 		case COPY_OLD_FE:
 			/* The FE/BE protocol uses \n as newline for all platforms */
-			if (!cstate->binary)
+			if (!cstate->binary && !cstate->raw)
 				CopySendChar(cstate, '\n');
 
 			if (pq_putbytes(fe_msgbuf->data, fe_msgbuf->len))
@@ -543,7 +566,7 @@ CopySendEndOfRow(CopyState cstate)
 			break;
 		case COPY_NEW_FE:
 			/* The FE/BE protocol uses \n as newline for all platforms */
-			if (!cstate->binary)
+			if (!cstate->binary && !cstate->raw)
 				CopySendChar(cstate, '\n');
 
 			/* Dump the accumulated row as one CopyData message */
@@ -600,6 +623,7 @@ CopyGetData(CopyState cstate, void *databuf, int minread, int maxread)
 			bytesread = minread;
 			break;
 		case COPY_NEW_FE:
+
 			while (maxread > 0 && bytesread < minread && !cstate->fe_eof)
 			{
 				int			avail;
@@ -769,6 +793,36 @@ CopyLoadRawBuf(CopyState cstate)
 	return (inbytes > 0);
 }
 
+/*
+ * CopyLoadAllRawBuf load all file into raw_buf.
+ *
+ * It is used for reading content in raw mode. If original RAW_BUF_SIZE is not
+ * enough, the buffer is enlarged.
+ */
+static void
+CopyLoadAllRawBuf(CopyState cstate)
+{
+	int			nbytes = 0;
+	int			inbytes;
+	Size			raw_buf_size = RAW_BUF_SIZE;
+
+	inbytes = CopyGetData(cstate, cstate->raw_buf + nbytes, 1, RAW_BUF_SIZE);
+	while (inbytes == RAW_BUF_SIZE)
+	{
+		nbytes += inbytes;
+
+		/* Have to enlarge raw_buf */
+		raw_buf_size += RAW_BUF_SIZE + 1;
+		cstate->raw_buf = repalloc(cstate->raw_buf, raw_buf_size);
+
+		inbytes = CopyGetData(cstate, cstate->raw_buf + nbytes, 1, RAW_BUF_SIZE);
+	}
+
+	nbytes += inbytes;
+	cstate->raw_buf[nbytes] = '\0';
+	cstate->raw_buf_index = 0;
+	cstate->raw_buf_len = nbytes;
+}
 
 /*
  *	 DoCopy executes the SQL COPY statement
@@ -1006,6 +1060,8 @@ ProcessCopyOptions(CopyState cstate,
 				cstate->csv_mode = true;
 			else if (strcmp(fmt, "binary") == 0)
 				cstate->binary = true;
+			else if (strcmp(fmt, "raw") == 0)
+				cstate->raw = true;
 			else
 				ereport(ERROR,
 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
@@ -1155,15 +1211,20 @@ ProcessCopyOptions(CopyState cstate,
 	 * Check for incompatible options (must do these two before inserting
 	 * defaults)
 	 */
-	if (cstate->binary && cstate->delim)
+	if ((cstate->binary || cstate->raw) && cstate->delim)
+		ereport(ERROR,
+				(errcode(ERRCODE_SYNTAX_ERROR),
+				 errmsg("cannot specify DELIMITER in BINARY or RAW mode")));
+
+	if ((cstate->binary || cstate->raw) && cstate->null_print)
 		ereport(ERROR,
 				(errcode(ERRCODE_SYNTAX_ERROR),
-				 errmsg("cannot specify DELIMITER in BINARY mode")));
+				 errmsg("cannot specify NULL in BINARY or RAW mode")));
 
-	if (cstate->binary && cstate->null_print)
+	if (cstate->raw && cstate->oids)
 		ereport(ERROR,
 				(errcode(ERRCODE_SYNTAX_ERROR),
-				 errmsg("cannot specify NULL in BINARY mode")));
+				 errmsg("cannot specify OIDS in RAW mode")));
 
 	/* Set defaults for omitted options */
 	if (!cstate->delim)
@@ -1559,6 +1620,20 @@ BeginCopy(bool is_from,
 		}
 	}
 
+	/*
+	 * Initializaze the field "row_processed" for one row output in RAW mode,
+	 * and ensure only one output column.
+	 */
+	if (cstate->raw)
+	{
+		cstate->row_processed = false;
+
+		if (num_phys_attrs > 1)
+			ereport(ERROR,
+					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+					 errmsg("only single column result is allowed in RAW mode")));
+	}
+
 	/* Use client encoding when ENCODING option is not specified. */
 	if (cstate->file_encoding < 0)
 		cstate->file_encoding = pg_get_client_encoding();
@@ -1821,7 +1896,7 @@ CopyTo(CopyState cstate)
 		Oid			out_func_oid;
 		bool		isvarlena;
 
-		if (cstate->binary)
+		if (cstate->binary || cstate->raw)
 			getTypeBinaryOutputInfo(attr[attnum - 1]->atttypid,
 									&out_func_oid,
 									&isvarlena);
@@ -1860,7 +1935,7 @@ CopyTo(CopyState cstate)
 		tmp = 0;
 		CopySendInt32(cstate, tmp);
 	}
-	else
+	else if (!cstate->raw)
 	{
 		/*
 		 * For non-binary copy, we need to convert null_print to file
@@ -1928,7 +2003,7 @@ CopyTo(CopyState cstate)
 	else
 	{
 		/* run the plan --- the dest receiver will send tuples */
-		ExecutorRun(cstate->queryDesc, ForwardScanDirection, 0L);
+		ExecutorRun(cstate->queryDesc, ForwardScanDirection, cstate->raw ? 2L : 0L);
 		processed = ((DR_copy *) cstate->queryDesc->dest)->processed;
 	}
 
@@ -1972,6 +2047,14 @@ CopyOneRowTo(CopyState cstate, Oid tupleOid, Datum *values, bool *nulls)
 			CopySendInt32(cstate, tupleOid);
 		}
 	}
+	else if (cstate->raw)
+	{
+		if (cstate->row_processed)
+			ereport(ERROR,
+					(errcode(ERRCODE_TOO_MANY_ROWS),
+					 errmsg("only single row result is allowed in RAW mode")));
+		cstate->row_processed = true;
+	}
 	else
 	{
 		/* Text format has no per-tuple header, but send OID if wanted */
@@ -1991,7 +2074,7 @@ CopyOneRowTo(CopyState cstate, Oid tupleOid, Datum *values, bool *nulls)
 		Datum		value = values[attnum - 1];
 		bool		isnull = nulls[attnum - 1];
 
-		if (!cstate->binary)
+		if (!cstate->binary && !cstate->raw)
 		{
 			if (need_delim)
 				CopySendChar(cstate, cstate->delim[0]);
@@ -2000,14 +2083,32 @@ CopyOneRowTo(CopyState cstate, Oid tupleOid, Datum *values, bool *nulls)
 
 		if (isnull)
 		{
-			if (!cstate->binary)
+			if (cstate->raw)
+					ereport(ERROR,
+						(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+						  errmsg("cannot to copy NULL value in RAW mode.")));
+			else if (!cstate->binary)
 				CopySendString(cstate, cstate->null_print_client);
 			else
 				CopySendInt32(cstate, -1);
 		}
 		else
 		{
-			if (!cstate->binary)
+			if (cstate->binary || cstate->raw)
+			{
+				bytea	   *outputbytes;
+
+				outputbytes = SendFunctionCall(&out_functions[attnum - 1],
+											   value);
+
+				/* send the size only in binary mode */
+				if (cstate->binary)
+					CopySendInt32(cstate, VARSIZE(outputbytes) - VARHDRSZ);
+
+				CopySendData(cstate, VARDATA(outputbytes),
+							 VARSIZE(outputbytes) - VARHDRSZ);
+			}
+			else
 			{
 				string = OutputFunctionCall(&out_functions[attnum - 1],
 											value);
@@ -2018,16 +2119,6 @@ CopyOneRowTo(CopyState cstate, Oid tupleOid, Datum *values, bool *nulls)
 				else
 					CopyAttributeOutText(cstate, string);
 			}
-			else
-			{
-				bytea	   *outputbytes;
-
-				outputbytes = SendFunctionCall(&out_functions[attnum - 1],
-											   value);
-				CopySendInt32(cstate, VARSIZE(outputbytes) - VARHDRSZ);
-				CopySendData(cstate, VARDATA(outputbytes),
-							 VARSIZE(outputbytes) - VARHDRSZ);
-			}
 		}
 	}
 
@@ -2657,7 +2748,7 @@ BeginCopyFrom(Relation rel,
 			continue;
 
 		/* Fetch the input function and typioparam info */
-		if (cstate->binary)
+		if (cstate->binary || cstate->raw)
 			getTypeBinaryInputInfo(attr[attnum - 1]->atttypid,
 								   &in_func_oid, &typioparams[attnum - 1]);
 		else
@@ -2752,7 +2843,7 @@ BeginCopyFrom(Relation rel,
 		}
 	}
 
-	if (!cstate->binary)
+	if (!cstate->binary || cstate->raw)
 	{
 		/* must rely on user to tell us... */
 		cstate->file_has_oids = cstate->oids;
@@ -2804,7 +2895,7 @@ BeginCopyFrom(Relation rel,
 	}
 
 	/* create workspace for CopyReadAttributes results */
-	if (!cstate->binary)
+	if (!cstate->binary && !cstate->raw)
 	{
 		AttrNumber	attr_count = list_length(cstate->attnumlist);
 		int			nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
@@ -2909,8 +3000,120 @@ NextCopyFrom(CopyState cstate, ExprContext *econtext,
 	MemSet(values, 0, num_phys_attrs * sizeof(Datum));
 	MemSet(nulls, true, num_phys_attrs * sizeof(bool));
 
-	if (!cstate->binary)
+	if (cstate->binary)
+	{
+		int16		fld_count;
+		ListCell   *cur;
+
+		cstate->cur_lineno++;
+
+		if (!CopyGetInt16(cstate, &fld_count))
+		{
+			/* EOF detected (end of file, or protocol-level EOF) */
+			return false;
+		}
+
+		if (fld_count == -1)
+		{
+			/*
+			 * Received EOF marker.  In a V3-protocol copy, wait for the
+			 * protocol-level EOF, and complain if it doesn't come
+			 * immediately.  This ensures that we correctly handle CopyFail,
+			 * if client chooses to send that now.
+			 *
+			 * Note that we MUST NOT try to read more data in an old-protocol
+			 * copy, since there is no protocol-level EOF marker then.  We
+			 * could go either way for copy from file, but choose to throw
+			 * error if there's data after the EOF marker, for consistency
+			 * with the new-protocol case.
+			 */
+			char		dummy;
+
+			if (cstate->copy_dest != COPY_OLD_FE &&
+				CopyGetData(cstate, &dummy, 1, 1) > 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
+						 errmsg("received copy data after EOF marker")));
+			return false;
+		}
+
+		if (fld_count != attr_count)
+			ereport(ERROR,
+					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
+					 errmsg("row field count is %d, expected %d",
+							(int) fld_count, attr_count)));
+
+		if (file_has_oids)
+		{
+			Oid			loaded_oid;
+
+			cstate->cur_attname = "oid";
+			loaded_oid =
+				DatumGetObjectId(CopyReadBinaryAttribute(cstate,
+														 0,
+													&cstate->oid_in_function,
+													  cstate->oid_typioparam,
+														 -1,
+														 &isnull));
+			if (isnull || loaded_oid == InvalidOid)
+				ereport(ERROR,
+						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
+						 errmsg("invalid OID in COPY data")));
+			cstate->cur_attname = NULL;
+			if (cstate->oids && tupleOid != NULL)
+				*tupleOid = loaded_oid;
+		}
+
+		i = 0;
+		foreach(cur, cstate->attnumlist)
+		{
+			int			attnum = lfirst_int(cur);
+			int			m = attnum - 1;
+
+			cstate->cur_attname = NameStr(attr[m]->attname);
+			i++;
+			values[m] = CopyReadBinaryAttribute(cstate,
+												i,
+												&in_functions[m],
+												typioparams[m],
+												attr[m]->atttypmod,
+												&nulls[m]);
+			cstate->cur_attname = NULL;
+		}
+	}
+	else if (cstate->raw)
 	{
+		if (cstate->row_processed)
+			return false;
+
+		CopyLoadAllRawBuf(cstate);
+		cstate->cur_attname = NameStr(attr[0]->attname);
+
+		if (cstate->attribute_buf.data != NULL)
+			pfree(cstate->attribute_buf.data);
+
+		cstate->attribute_buf.data = cstate->raw_buf;
+		cstate->attribute_buf.len = cstate->raw_buf_len;
+		cstate->attribute_buf.cursor = 0;
+
+		cstate->raw_buf = NULL;
+
+		/* Call the column type's binary input converter */
+		values[0] = ReceiveFunctionCall(&in_functions[0], &cstate->attribute_buf,
+								 typioparams[0], attr[0]->atttypmod);
+		nulls[0] = false;
+
+		/* Trouble if it didn't eat the whole buffer */
+		if (cstate->attribute_buf.cursor != cstate->attribute_buf.len)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
+					 errmsg("incorrect binary data format")));
+
+		cstate->row_processed = true;
+	}
+	else
+	{
+		/* text */
 		char	  **field_strings;
 		ListCell   *cur;
 		int			fldct;
@@ -3015,88 +3218,6 @@ NextCopyFrom(CopyState cstate, ExprContext *econtext,
 
 		Assert(fieldno == nfields);
 	}
-	else
-	{
-		/* binary */
-		int16		fld_count;
-		ListCell   *cur;
-
-		cstate->cur_lineno++;
-
-		if (!CopyGetInt16(cstate, &fld_count))
-		{
-			/* EOF detected (end of file, or protocol-level EOF) */
-			return false;
-		}
-
-		if (fld_count == -1)
-		{
-			/*
-			 * Received EOF marker.  In a V3-protocol copy, wait for the
-			 * protocol-level EOF, and complain if it doesn't come
-			 * immediately.  This ensures that we correctly handle CopyFail,
-			 * if client chooses to send that now.
-			 *
-			 * Note that we MUST NOT try to read more data in an old-protocol
-			 * copy, since there is no protocol-level EOF marker then.  We
-			 * could go either way for copy from file, but choose to throw
-			 * error if there's data after the EOF marker, for consistency
-			 * with the new-protocol case.
-			 */
-			char		dummy;
-
-			if (cstate->copy_dest != COPY_OLD_FE &&
-				CopyGetData(cstate, &dummy, 1, 1) > 0)
-				ereport(ERROR,
-						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
-						 errmsg("received copy data after EOF marker")));
-			return false;
-		}
-
-		if (fld_count != attr_count)
-			ereport(ERROR,
-					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
-					 errmsg("row field count is %d, expected %d",
-							(int) fld_count, attr_count)));
-
-		if (file_has_oids)
-		{
-			Oid			loaded_oid;
-
-			cstate->cur_attname = "oid";
-			loaded_oid =
-				DatumGetObjectId(CopyReadBinaryAttribute(cstate,
-														 0,
-													&cstate->oid_in_function,
-													  cstate->oid_typioparam,
-														 -1,
-														 &isnull));
-			if (isnull || loaded_oid == InvalidOid)
-				ereport(ERROR,
-						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
-						 errmsg("invalid OID in COPY data")));
-			cstate->cur_attname = NULL;
-			if (cstate->oids && tupleOid != NULL)
-				*tupleOid = loaded_oid;
-		}
-
-		i = 0;
-		foreach(cur, cstate->attnumlist)
-		{
-			int			attnum = lfirst_int(cur);
-			int			m = attnum - 1;
-
-			cstate->cur_attname = NameStr(attr[m]->attname);
-			i++;
-			values[m] = CopyReadBinaryAttribute(cstate,
-												i,
-												&in_functions[m],
-												typioparams[m],
-												attr[m]->atttypmod,
-												&nulls[m]);
-			cstate->cur_attname = NULL;
-		}
-	}
 
 	/*
 	 * Now compute and insert any defaults available for the columns not
diff --git a/src/test/regress/expected/copy2.out b/src/test/regress/expected/copy2.out
index 5e31737..30e77ca 100644
--- a/src/test/regress/expected/copy2.out
+++ b/src/test/regress/expected/copy2.out
@@ -469,3 +469,16 @@ DROP FUNCTION truncate_in_subxact();
 DROP TABLE x, y;
 DROP FUNCTION fn_x_before();
 DROP FUNCTION fn_x_after();
+CREATE TABLE x(a bytea);
+INSERT INTO x VALUES('\x41484f4a0a');
+INSERT INTO x VALUES('\x41484f4a0a');
+-- should to fail
+COPY (SELECT a,a FROM x LIMIT 1) TO STDOUT (FORMAT raw);
+ERROR:  only single column result is allowed in RAW mode
+COPY (SELECT a FROM x) TO STDOUT (FORMAT raw);
+AHOJ
+ERROR:  only single row result is allowed in RAW mode
+-- should be ok
+COPY (SELECT a FROM x LIMIT 1) TO STDOUT (FORMAT raw);
+AHOJ
+DROP TABLE x;
diff --git a/src/test/regress/input/copy.source b/src/test/regress/input/copy.source
index cb13606..d8970b1 100644
--- a/src/test/regress/input/copy.source
+++ b/src/test/regress/input/copy.source
@@ -133,3 +133,36 @@ this is just a line full of junk that would error out if parsed
 \.
 
 copy copytest3 to stdout csv header;
+
+-- copy raw
+CREATE TABLE x(a bytea);
+INSERT INTO x VALUES('\x41484f4a0a');
+SELECT length(a) FROM x;
+
+INSERT INTO x VALUES('\x41484f4a0a');
+
+-- should to fail
+COPY (SELECT a,a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+COPY (SELECT a FROM x) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+
+-- should be ok
+COPY (SELECT a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+TRUNCATE x;
+COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw);
+SELECT length(a) FROM x;
+COPY x TO stdout (FORMAT raw);
+
+TRUNCATE x;
+
+\COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw)
+SELECT length(a) FROM x;
+COPY x TO stdout (FORMAT raw);
+
+\COPY x TO '@abs_builddir@/results/raw2.data' (FORMAT raw)
+TRUNCATE x;
+
+\COPY x FROM '@abs_builddir@/results/raw2.data' (FORMAT raw)
+SELECT length(a) FROM x;
+COPY x TO stdout (FORMAT raw);
+
+DROP TABLE x;
diff --git a/src/test/regress/output/copy.source b/src/test/regress/output/copy.source
index b7e372d..878797a 100644
--- a/src/test/regress/output/copy.source
+++ b/src/test/regress/output/copy.source
@@ -95,3 +95,52 @@ copy copytest3 to stdout csv header;
 c1,"col with , comma","col with "" quote"
 1,a,1
 2,b,2
+-- copy raw
+CREATE TABLE x(a bytea);
+INSERT INTO x VALUES('\x41484f4a0a');
+SELECT length(a) FROM x;
+ length 
+--------
+      5
+(1 row)
+
+INSERT INTO x VALUES('\x41484f4a0a');
+-- should to fail
+COPY (SELECT a,a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+ERROR:  only single column result is allowed in RAW mode
+COPY (SELECT a FROM x) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+ERROR:  only single row result is allowed in RAW mode
+-- should be ok
+COPY (SELECT a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+TRUNCATE x;
+COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw);
+SELECT length(a) FROM x;
+ length 
+--------
+      5
+(1 row)
+
+COPY x TO stdout (FORMAT raw);
+AHOJ
+TRUNCATE x;
+\COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw)
+SELECT length(a) FROM x;
+ length 
+--------
+      5
+(1 row)
+
+COPY x TO stdout (FORMAT raw);
+AHOJ
+\COPY x TO '@abs_builddir@/results/raw2.data' (FORMAT raw)
+TRUNCATE x;
+\COPY x FROM '@abs_builddir@/results/raw2.data' (FORMAT raw)
+SELECT length(a) FROM x;
+ length 
+--------
+      5
+(1 row)
+
+COPY x TO stdout (FORMAT raw);
+AHOJ
+DROP TABLE x;
diff --git a/src/test/regress/sql/copy2.sql b/src/test/regress/sql/copy2.sql
index 39a9deb..e5703a5 100644
--- a/src/test/regress/sql/copy2.sql
+++ b/src/test/regress/sql/copy2.sql
@@ -333,3 +333,16 @@ DROP FUNCTION truncate_in_subxact();
 DROP TABLE x, y;
 DROP FUNCTION fn_x_before();
 DROP FUNCTION fn_x_after();
+
+CREATE TABLE x(a bytea);
+INSERT INTO x VALUES('\x41484f4a0a');
+INSERT INTO x VALUES('\x41484f4a0a');
+
+-- should to fail
+COPY (SELECT a,a FROM x LIMIT 1) TO STDOUT (FORMAT raw);
+COPY (SELECT a FROM x) TO STDOUT (FORMAT raw);
+
+-- should be ok
+COPY (SELECT a FROM x LIMIT 1) TO STDOUT (FORMAT raw);
+
+DROP TABLE x;

diff --git a/doc/src/sgml/ref/copy.sgml b/doc/src/sgml/ref/copy.sgml
new file mode 100644
index 2850b47..5739158
*** a/doc/src/sgml/ref/copy.sgml
--- b/doc/src/sgml/ref/copy.sgml
*************** COPY { <replaceable class="parameter">ta
*** 190,196 ****
        Selects the data format to be read or written:
        <literal>text</>,
        <literal>csv</> (Comma Separated Values),
!       or <literal>binary</>.
        The default is <literal>text</>.
       </para>
      </listitem>
--- 190,196 ----
        Selects the data format to be read or written:
        <literal>text</>,
        <literal>csv</> (Comma Separated Values),
!       <literal>binary</> or <literal>raw</literal>.
        The default is <literal>text</>.
       </para>
      </listitem>
*************** OIDs to be shown as null if that ever pr
*** 881,886 ****
--- 881,918 ----
      </para>
     </refsect3>
    </refsect2>
+ 
+   <refsect2>
+      <title>Raw Format</title>
+ 
+    <para>
+     The <literal>raw</literal> format option causes all data to be
+     stored/read as binary format rather than as text. It shares format
+     for data with <literal>binary</literal> format. This format doesn't
+     use any metadata - only row data in network byte order are exported
+     or imported.
+    </para>
+ 
+    <para>
+     Because this format doesn't support any delimiter, only one value
+     can be exported or imported. NULL values are not allowed.
+    </para>
+    <para>
+     The <literal>raw</literal> format can be used for export or import
+     bytea values.
+ <programlisting>
+ COPY images(data) FROM '/usr1/proj/img/01.jpg' (FORMAT raw);
+ </programlisting>
+     It can be used successfully for export XML in different encoding
+     or import valid XML document with any supported encoding:
+ <screen><![CDATA[
+ SET client_encoding TO latin2;
+ 
+ COPY (SELECT xmlelement(NAME data, 'Hello')) TO stdout (FORMAT raw);
+ <?xml version="1.0" encoding="LATIN2"?><data>Hello</data>
+ ]]></screen>
+    </para>
+   </refsect2>
   </refsect1>
  
   <refsect1>
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
new file mode 100644
index 8904676..c69854c
*** a/src/backend/commands/copy.c
--- b/src/backend/commands/copy.c
*************** typedef enum EolType
*** 92,97 ****
--- 92,102 ----
   * it's faster to make useless comparisons to trailing bytes than it is to
   * invoke pg_encoding_mblen() to skip over them. encoding_embeds_ascii is TRUE
   * when we have to do it the hard way.
+  *
+  * COPY supports three modes: text, binary and raw. The text format is plain
+  * text multiline format with specified delimiter. The binary format holds
+  * metadata (numbers, sizes) and data. The raw format holds data only and
+  * only one non NULL value can be processed.
   */
  typedef struct CopyStateData
  {
*************** typedef struct CopyStateData
*** 113,118 ****
--- 118,124 ----
  	char	   *filename;		/* filename, or NULL for STDIN/STDOUT */
  	bool		is_program;		/* is 'filename' a program to popen? */
  	bool		binary;			/* binary format? */
+ 	bool		raw;			/* required raw binary? */
  	bool		oids;			/* include OIDs? */
  	bool		freeze;			/* freeze rows on loading? */
  	bool		csv_mode;		/* Comma Separated Value format? */
*************** typedef struct CopyStateData
*** 202,207 ****
--- 208,216 ----
  	char	   *raw_buf;
  	int			raw_buf_index;	/* next byte to process */
  	int			raw_buf_len;	/* total # of bytes stored */
+ 
+ 	/* field for RAW mode */
+ 	bool		row_processed;		/* true, when first row was processed */
  } CopyStateData;
  
  /* DestReceiver for COPY (SELECT) TO */
*************** SendCopyBegin(CopyState cstate)
*** 345,353 ****
  		/* new way */
  		StringInfoData buf;
  		int			natts = list_length(cstate->attnumlist);
! 		int16		format = (cstate->binary ? 1 : 0);
  		int			i;
  
  		pq_beginmessage(&buf, 'H');
  		pq_sendbyte(&buf, format);		/* overall format */
  		pq_sendint(&buf, natts, 2);
--- 354,369 ----
  		/* new way */
  		StringInfoData buf;
  		int			natts = list_length(cstate->attnumlist);
! 		int16		format;
  		int			i;
  
+ 		if (cstate->raw)
+ 			format = 2;
+ 		else if (cstate->binary)
+ 			format = 1;
+ 		else
+ 			format = 0;
+ 
  		pq_beginmessage(&buf, 'H');
  		pq_sendbyte(&buf, format);		/* overall format */
  		pq_sendint(&buf, natts, 2);
*************** SendCopyBegin(CopyState cstate)
*** 359,365 ****
  	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
  	{
  		/* old way */
! 		if (cstate->binary)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
--- 375,381 ----
  	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
  	{
  		/* old way */
! 		if (cstate->binary && cstate->raw)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
*************** SendCopyBegin(CopyState cstate)
*** 371,377 ****
  	else
  	{
  		/* very old way */
! 		if (cstate->binary)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
--- 387,393 ----
  	else
  	{
  		/* very old way */
! 		if (cstate->binary && cstate->raw)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
*************** ReceiveCopyBegin(CopyState cstate)
*** 390,398 ****
  		/* new way */
  		StringInfoData buf;
  		int			natts = list_length(cstate->attnumlist);
! 		int16		format = (cstate->binary ? 1 : 0);
  		int			i;
  
  		pq_beginmessage(&buf, 'G');
  		pq_sendbyte(&buf, format);		/* overall format */
  		pq_sendint(&buf, natts, 2);
--- 406,421 ----
  		/* new way */
  		StringInfoData buf;
  		int			natts = list_length(cstate->attnumlist);
! 		int16		format;
  		int			i;
  
+ 		if (cstate->raw)
+ 			format = 2;
+ 		else if (cstate->binary)
+ 			format = 1;
+ 		else
+ 			format = 0;
+ 
  		pq_beginmessage(&buf, 'G');
  		pq_sendbyte(&buf, format);		/* overall format */
  		pq_sendint(&buf, natts, 2);
*************** ReceiveCopyBegin(CopyState cstate)
*** 405,411 ****
  	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
  	{
  		/* old way */
! 		if (cstate->binary)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
--- 428,434 ----
  	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
  	{
  		/* old way */
! 		if (cstate->binary || cstate->raw)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
*************** ReceiveCopyBegin(CopyState cstate)
*** 417,423 ****
  	else
  	{
  		/* very old way */
! 		if (cstate->binary)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
--- 440,446 ----
  	else
  	{
  		/* very old way */
! 		if (cstate->binary || cstate->raw)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
*************** CopySendEndOfRow(CopyState cstate)
*** 485,491 ****
  	switch (cstate->copy_dest)
  	{
  		case COPY_FILE:
! 			if (!cstate->binary)
  			{
  				/* Default line termination depends on platform */
  #ifndef WIN32
--- 508,514 ----
  	switch (cstate->copy_dest)
  	{
  		case COPY_FILE:
! 			if (!cstate->binary && !cstate->raw)
  			{
  				/* Default line termination depends on platform */
  #ifndef WIN32
*************** CopySendEndOfRow(CopyState cstate)
*** 530,536 ****
  			break;
  		case COPY_OLD_FE:
  			/* The FE/BE protocol uses \n as newline for all platforms */
! 			if (!cstate->binary)
  				CopySendChar(cstate, '\n');
  
  			if (pq_putbytes(fe_msgbuf->data, fe_msgbuf->len))
--- 553,559 ----
  			break;
  		case COPY_OLD_FE:
  			/* The FE/BE protocol uses \n as newline for all platforms */
! 			if (!cstate->binary && !cstate->raw)
  				CopySendChar(cstate, '\n');
  
  			if (pq_putbytes(fe_msgbuf->data, fe_msgbuf->len))
*************** CopySendEndOfRow(CopyState cstate)
*** 543,549 ****
  			break;
  		case COPY_NEW_FE:
  			/* The FE/BE protocol uses \n as newline for all platforms */
! 			if (!cstate->binary)
  				CopySendChar(cstate, '\n');
  
  			/* Dump the accumulated row as one CopyData message */
--- 566,572 ----
  			break;
  		case COPY_NEW_FE:
  			/* The FE/BE protocol uses \n as newline for all platforms */
! 			if (!cstate->binary && !cstate->raw)
  				CopySendChar(cstate, '\n');
  
  			/* Dump the accumulated row as one CopyData message */
*************** CopyGetData(CopyState cstate, void *data
*** 600,605 ****
--- 623,629 ----
  			bytesread = minread;
  			break;
  		case COPY_NEW_FE:
+ 
  			while (maxread > 0 && bytesread < minread && !cstate->fe_eof)
  			{
  				int			avail;
*************** CopyGetData(CopyState cstate, void *data
*** 622,627 ****
--- 646,652 ----
  								(errcode(ERRCODE_CONNECTION_FAILURE),
  								 errmsg("unexpected EOF on client connection with an open transaction")));
  					RESUME_CANCEL_INTERRUPTS();
+ 
  					switch (mtype)
  					{
  						case 'd':		/* CopyData */
*************** CopyLoadRawBuf(CopyState cstate)
*** 769,774 ****
--- 794,830 ----
  	return (inbytes > 0);
  }
  
+ /*
+  * CopyLoadallRawBuf load all file into raw_buf.
+  *
+  * It is used for reading content in raw mode. If original RAW_BUF_SIZE is not
+  * enough, the buffer is enlarged.
+  */
+ static void
+ CopyLoadallRawBuf(CopyState cstate)
+ {
+ 	int			nbytes = 0;
+ 	int			inbytes;
+ 	Size			raw_buf_size = RAW_BUF_SIZE;
+ 
+ 	do
+ 	{
+ 		/* hold enough space for one data packet */
+ 		if ((raw_buf_size - nbytes - 1) < 8 * 1024)
+ 		{
+ 			raw_buf_size += RAW_BUF_SIZE;
+ 			cstate->raw_buf = repalloc(cstate->raw_buf, raw_buf_size);
+ 		}
+ 
+ 		inbytes = CopyGetData(cstate, cstate->raw_buf + nbytes, 1, raw_buf_size - nbytes - 1);
+ 		nbytes += inbytes;
+ 	}
+ 	while (inbytes > 0);
+ 
+ 	cstate->raw_buf[nbytes] = '\0';
+ 	cstate->raw_buf_index = 0;
+ 	cstate->raw_buf_len = nbytes;
+ }
  
  /*
   *	 DoCopy executes the SQL COPY statement
*************** ProcessCopyOptions(CopyState cstate,
*** 1006,1011 ****
--- 1062,1069 ----
  				cstate->csv_mode = true;
  			else if (strcmp(fmt, "binary") == 0)
  				cstate->binary = true;
+ 			else if (strcmp(fmt, "raw") == 0)
+ 				cstate->raw = true;
  			else
  				ereport(ERROR,
  						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
*************** ProcessCopyOptions(CopyState cstate,
*** 1155,1169 ****
  	 * Check for incompatible options (must do these two before inserting
  	 * defaults)
  	 */
! 	if (cstate->binary && cstate->delim)
  		ereport(ERROR,
  				(errcode(ERRCODE_SYNTAX_ERROR),
! 				 errmsg("cannot specify DELIMITER in BINARY mode")));
  
! 	if (cstate->binary && cstate->null_print)
  		ereport(ERROR,
  				(errcode(ERRCODE_SYNTAX_ERROR),
! 				 errmsg("cannot specify NULL in BINARY mode")));
  
  	/* Set defaults for omitted options */
  	if (!cstate->delim)
--- 1213,1232 ----
  	 * Check for incompatible options (must do these two before inserting
  	 * defaults)
  	 */
! 	if ((cstate->binary || cstate->raw) && cstate->delim)
  		ereport(ERROR,
  				(errcode(ERRCODE_SYNTAX_ERROR),
! 				 errmsg("cannot specify DELIMITER in BINARY or RAW mode")));
  
! 	if ((cstate->binary || cstate->raw) && cstate->null_print)
  		ereport(ERROR,
  				(errcode(ERRCODE_SYNTAX_ERROR),
! 				 errmsg("cannot specify NULL in BINARY or RAW mode")));
! 
! 	if (cstate->raw && cstate->oids)
! 		ereport(ERROR,
! 				(errcode(ERRCODE_SYNTAX_ERROR),
! 				 errmsg("cannot specify OIDS in RAW mode")));
  
  	/* Set defaults for omitted options */
  	if (!cstate->delim)
*************** BeginCopy(bool is_from,
*** 1559,1564 ****
--- 1622,1641 ----
  		}
  	}
  
+ 	/*
+ 	 * Initializaze the field "row_processed" for one row output in RAW mode,
+ 	 * and ensure only one output column.
+ 	 */
+ 	if (cstate->raw)
+ 	{
+ 		cstate->row_processed = false;
+ 
+ 		if (num_phys_attrs > 1)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 					 errmsg("only single column result is allowed in RAW mode")));
+ 	}
+ 
  	/* Use client encoding when ENCODING option is not specified. */
  	if (cstate->file_encoding < 0)
  		cstate->file_encoding = pg_get_client_encoding();
*************** CopyTo(CopyState cstate)
*** 1821,1827 ****
  		Oid			out_func_oid;
  		bool		isvarlena;
  
! 		if (cstate->binary)
  			getTypeBinaryOutputInfo(attr[attnum - 1]->atttypid,
  									&out_func_oid,
  									&isvarlena);
--- 1898,1904 ----
  		Oid			out_func_oid;
  		bool		isvarlena;
  
! 		if (cstate->binary || cstate->raw)
  			getTypeBinaryOutputInfo(attr[attnum - 1]->atttypid,
  									&out_func_oid,
  									&isvarlena);
*************** CopyTo(CopyState cstate)
*** 1860,1866 ****
  		tmp = 0;
  		CopySendInt32(cstate, tmp);
  	}
! 	else
  	{
  		/*
  		 * For non-binary copy, we need to convert null_print to file
--- 1937,1943 ----
  		tmp = 0;
  		CopySendInt32(cstate, tmp);
  	}
! 	else if (!cstate->raw)
  	{
  		/*
  		 * For non-binary copy, we need to convert null_print to file
*************** CopyTo(CopyState cstate)
*** 1928,1934 ****
  	else
  	{
  		/* run the plan --- the dest receiver will send tuples */
! 		ExecutorRun(cstate->queryDesc, ForwardScanDirection, 0L);
  		processed = ((DR_copy *) cstate->queryDesc->dest)->processed;
  	}
  
--- 2005,2011 ----
  	else
  	{
  		/* run the plan --- the dest receiver will send tuples */
! 		ExecutorRun(cstate->queryDesc, ForwardScanDirection, cstate->raw ? 2L : 0L);
  		processed = ((DR_copy *) cstate->queryDesc->dest)->processed;
  	}
  
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 1972,1977 ****
--- 2049,2062 ----
  			CopySendInt32(cstate, tupleOid);
  		}
  	}
+ 	else if (cstate->raw)
+ 	{
+ 		if (cstate->row_processed)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_TOO_MANY_ROWS),
+ 					 errmsg("only single row result is allowed in RAW mode")));
+ 		cstate->row_processed = true;
+ 	}
  	else
  	{
  		/* Text format has no per-tuple header, but send OID if wanted */
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 1991,1997 ****
  		Datum		value = values[attnum - 1];
  		bool		isnull = nulls[attnum - 1];
  
! 		if (!cstate->binary)
  		{
  			if (need_delim)
  				CopySendChar(cstate, cstate->delim[0]);
--- 2076,2082 ----
  		Datum		value = values[attnum - 1];
  		bool		isnull = nulls[attnum - 1];
  
! 		if (!cstate->binary && !cstate->raw)
  		{
  			if (need_delim)
  				CopySendChar(cstate, cstate->delim[0]);
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 2000,2013 ****
  
  		if (isnull)
  		{
! 			if (!cstate->binary)
  				CopySendString(cstate, cstate->null_print_client);
  			else
  				CopySendInt32(cstate, -1);
  		}
  		else
  		{
! 			if (!cstate->binary)
  			{
  				string = OutputFunctionCall(&out_functions[attnum - 1],
  											value);
--- 2085,2116 ----
  
  		if (isnull)
  		{
! 			if (cstate->raw)
! 					ereport(ERROR,
! 						(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
! 						  errmsg("cannot to copy NULL value in RAW mode.")));
! 			else if (!cstate->binary)
  				CopySendString(cstate, cstate->null_print_client);
  			else
  				CopySendInt32(cstate, -1);
  		}
  		else
  		{
! 			if (cstate->binary || cstate->raw)
! 			{
! 				bytea	   *outputbytes;
! 
! 				outputbytes = SendFunctionCall(&out_functions[attnum - 1],
! 											   value);
! 
! 				/* send the size only in binary mode */
! 				if (cstate->binary)
! 					CopySendInt32(cstate, VARSIZE(outputbytes) - VARHDRSZ);
! 
! 				CopySendData(cstate, VARDATA(outputbytes),
! 							 VARSIZE(outputbytes) - VARHDRSZ);
! 			}
! 			else
  			{
  				string = OutputFunctionCall(&out_functions[attnum - 1],
  											value);
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 2018,2033 ****
  				else
  					CopyAttributeOutText(cstate, string);
  			}
- 			else
- 			{
- 				bytea	   *outputbytes;
- 
- 				outputbytes = SendFunctionCall(&out_functions[attnum - 1],
- 											   value);
- 				CopySendInt32(cstate, VARSIZE(outputbytes) - VARHDRSZ);
- 				CopySendData(cstate, VARDATA(outputbytes),
- 							 VARSIZE(outputbytes) - VARHDRSZ);
- 			}
  		}
  	}
  
--- 2121,2126 ----
*************** BeginCopyFrom(Relation rel,
*** 2657,2663 ****
  			continue;
  
  		/* Fetch the input function and typioparam info */
! 		if (cstate->binary)
  			getTypeBinaryInputInfo(attr[attnum - 1]->atttypid,
  								   &in_func_oid, &typioparams[attnum - 1]);
  		else
--- 2750,2756 ----
  			continue;
  
  		/* Fetch the input function and typioparam info */
! 		if (cstate->binary || cstate->raw)
  			getTypeBinaryInputInfo(attr[attnum - 1]->atttypid,
  								   &in_func_oid, &typioparams[attnum - 1]);
  		else
*************** BeginCopyFrom(Relation rel,
*** 2752,2758 ****
  		}
  	}
  
! 	if (!cstate->binary)
  	{
  		/* must rely on user to tell us... */
  		cstate->file_has_oids = cstate->oids;
--- 2845,2851 ----
  		}
  	}
  
! 	if (!cstate->binary || cstate->raw)
  	{
  		/* must rely on user to tell us... */
  		cstate->file_has_oids = cstate->oids;
*************** BeginCopyFrom(Relation rel,
*** 2804,2810 ****
  	}
  
  	/* create workspace for CopyReadAttributes results */
! 	if (!cstate->binary)
  	{
  		AttrNumber	attr_count = list_length(cstate->attnumlist);
  		int			nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
--- 2897,2903 ----
  	}
  
  	/* create workspace for CopyReadAttributes results */
! 	if (!cstate->binary && !cstate->raw)
  	{
  		AttrNumber	attr_count = list_length(cstate->attnumlist);
  		int			nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
*************** NextCopyFrom(CopyState cstate, ExprConte
*** 2909,2916 ****
  	MemSet(values, 0, num_phys_attrs * sizeof(Datum));
  	MemSet(nulls, true, num_phys_attrs * sizeof(bool));
  
! 	if (!cstate->binary)
  	{
  		char	  **field_strings;
  		ListCell   *cur;
  		int			fldct;
--- 3002,3121 ----
  	MemSet(values, 0, num_phys_attrs * sizeof(Datum));
  	MemSet(nulls, true, num_phys_attrs * sizeof(bool));
  
! 	if (cstate->binary)
  	{
+ 		int16		fld_count;
+ 		ListCell   *cur;
+ 
+ 		cstate->cur_lineno++;
+ 
+ 		if (!CopyGetInt16(cstate, &fld_count))
+ 		{
+ 			/* EOF detected (end of file, or protocol-level EOF) */
+ 			return false;
+ 		}
+ 
+ 		if (fld_count == -1)
+ 		{
+ 			/*
+ 			 * Received EOF marker.  In a V3-protocol copy, wait for the
+ 			 * protocol-level EOF, and complain if it doesn't come
+ 			 * immediately.  This ensures that we correctly handle CopyFail,
+ 			 * if client chooses to send that now.
+ 			 *
+ 			 * Note that we MUST NOT try to read more data in an old-protocol
+ 			 * copy, since there is no protocol-level EOF marker then.  We
+ 			 * could go either way for copy from file, but choose to throw
+ 			 * error if there's data after the EOF marker, for consistency
+ 			 * with the new-protocol case.
+ 			 */
+ 			char		dummy;
+ 
+ 			if (cstate->copy_dest != COPY_OLD_FE &&
+ 				CopyGetData(cstate, &dummy, 1, 1) > 0)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
+ 						 errmsg("received copy data after EOF marker")));
+ 			return false;
+ 		}
+ 
+ 		if (fld_count != attr_count)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
+ 					 errmsg("row field count is %d, expected %d",
+ 							(int) fld_count, attr_count)));
+ 
+ 		if (file_has_oids)
+ 		{
+ 			Oid			loaded_oid;
+ 
+ 			cstate->cur_attname = "oid";
+ 			loaded_oid =
+ 				DatumGetObjectId(CopyReadBinaryAttribute(cstate,
+ 														 0,
+ 													&cstate->oid_in_function,
+ 													  cstate->oid_typioparam,
+ 														 -1,
+ 														 &isnull));
+ 			if (isnull || loaded_oid == InvalidOid)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
+ 						 errmsg("invalid OID in COPY data")));
+ 			cstate->cur_attname = NULL;
+ 			if (cstate->oids && tupleOid != NULL)
+ 				*tupleOid = loaded_oid;
+ 		}
+ 
+ 		i = 0;
+ 		foreach(cur, cstate->attnumlist)
+ 		{
+ 			int			attnum = lfirst_int(cur);
+ 			int			m = attnum - 1;
+ 
+ 			cstate->cur_attname = NameStr(attr[m]->attname);
+ 			i++;
+ 			values[m] = CopyReadBinaryAttribute(cstate,
+ 												i,
+ 												&in_functions[m],
+ 												typioparams[m],
+ 												attr[m]->atttypmod,
+ 												&nulls[m]);
+ 			cstate->cur_attname = NULL;
+ 		}
+ 	}
+ 	else if (cstate->raw)
+ 	{
+ 		if (cstate->row_processed)
+ 			return false;
+ 
+ 		CopyLoadallRawBuf(cstate);
+ 		cstate->cur_attname = NameStr(attr[0]->attname);
+ 
+ 		if (cstate->attribute_buf.data != NULL)
+ 			pfree(cstate->attribute_buf.data);
+ 
+ 		cstate->attribute_buf.data = cstate->raw_buf;
+ 		cstate->attribute_buf.len = cstate->raw_buf_len;
+ 		cstate->attribute_buf.cursor = 0;
+ 
+ 		cstate->raw_buf = NULL;
+ 
+ 		/* Call the column type's binary input converter */
+ 		values[0] = ReceiveFunctionCall(&in_functions[0], &cstate->attribute_buf,
+ 								 typioparams[0], attr[0]->atttypmod);
+ 		nulls[0] = false;
+ 
+ 		/* Trouble if it didn't eat the whole buffer */
+ 		if (cstate->attribute_buf.cursor != cstate->attribute_buf.len)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
+ 					 errmsg("incorrect binary data format")));
+ 
+ 		cstate->row_processed = true;
+ 	}
+ 	else
+ 	{
+ 		/* text */
  		char	  **field_strings;
  		ListCell   *cur;
  		int			fldct;
*************** NextCopyFrom(CopyState cstate, ExprConte
*** 3015,3102 ****
  
  		Assert(fieldno == nfields);
  	}
- 	else
- 	{
- 		/* binary */
- 		int16		fld_count;
- 		ListCell   *cur;
- 
- 		cstate->cur_lineno++;
- 
- 		if (!CopyGetInt16(cstate, &fld_count))
- 		{
- 			/* EOF detected (end of file, or protocol-level EOF) */
- 			return false;
- 		}
- 
- 		if (fld_count == -1)
- 		{
- 			/*
- 			 * Received EOF marker.  In a V3-protocol copy, wait for the
- 			 * protocol-level EOF, and complain if it doesn't come
- 			 * immediately.  This ensures that we correctly handle CopyFail,
- 			 * if client chooses to send that now.
- 			 *
- 			 * Note that we MUST NOT try to read more data in an old-protocol
- 			 * copy, since there is no protocol-level EOF marker then.  We
- 			 * could go either way for copy from file, but choose to throw
- 			 * error if there's data after the EOF marker, for consistency
- 			 * with the new-protocol case.
- 			 */
- 			char		dummy;
- 
- 			if (cstate->copy_dest != COPY_OLD_FE &&
- 				CopyGetData(cstate, &dummy, 1, 1) > 0)
- 				ereport(ERROR,
- 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
- 						 errmsg("received copy data after EOF marker")));
- 			return false;
- 		}
- 
- 		if (fld_count != attr_count)
- 			ereport(ERROR,
- 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
- 					 errmsg("row field count is %d, expected %d",
- 							(int) fld_count, attr_count)));
- 
- 		if (file_has_oids)
- 		{
- 			Oid			loaded_oid;
- 
- 			cstate->cur_attname = "oid";
- 			loaded_oid =
- 				DatumGetObjectId(CopyReadBinaryAttribute(cstate,
- 														 0,
- 													&cstate->oid_in_function,
- 													  cstate->oid_typioparam,
- 														 -1,
- 														 &isnull));
- 			if (isnull || loaded_oid == InvalidOid)
- 				ereport(ERROR,
- 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
- 						 errmsg("invalid OID in COPY data")));
- 			cstate->cur_attname = NULL;
- 			if (cstate->oids && tupleOid != NULL)
- 				*tupleOid = loaded_oid;
- 		}
- 
- 		i = 0;
- 		foreach(cur, cstate->attnumlist)
- 		{
- 			int			attnum = lfirst_int(cur);
- 			int			m = attnum - 1;
- 
- 			cstate->cur_attname = NameStr(attr[m]->attname);
- 			i++;
- 			values[m] = CopyReadBinaryAttribute(cstate,
- 												i,
- 												&in_functions[m],
- 												typioparams[m],
- 												attr[m]->atttypmod,
- 												&nulls[m]);
- 			cstate->cur_attname = NULL;
- 		}
- 	}
  
  	/*
  	 * Now compute and insert any defaults available for the columns not
--- 3220,3225 ----
diff --git a/src/test/regress/expected/copy2.out b/src/test/regress/expected/copy2.out
new file mode 100644
index 5e31737..30e77ca
*** a/src/test/regress/expected/copy2.out
--- b/src/test/regress/expected/copy2.out
*************** DROP FUNCTION truncate_in_subxact();
*** 469,471 ****
--- 469,484 ----
  DROP TABLE x, y;
  DROP FUNCTION fn_x_before();
  DROP FUNCTION fn_x_after();
+ CREATE TABLE x(a bytea);
+ INSERT INTO x VALUES('\x41484f4a0a');
+ INSERT INTO x VALUES('\x41484f4a0a');
+ -- should to fail
+ COPY (SELECT a,a FROM x LIMIT 1) TO STDOUT (FORMAT raw);
+ ERROR:  only single column result is allowed in RAW mode
+ COPY (SELECT a FROM x) TO STDOUT (FORMAT raw);
+ AHOJ
+ ERROR:  only single row result is allowed in RAW mode
+ -- should be ok
+ COPY (SELECT a FROM x LIMIT 1) TO STDOUT (FORMAT raw);
+ AHOJ
+ DROP TABLE x;
diff --git a/src/test/regress/input/copy.source b/src/test/regress/input/copy.source
new file mode 100644
index cb13606..d351b43
*** a/src/test/regress/input/copy.source
--- b/src/test/regress/input/copy.source
*************** this is just a line full of junk that wo
*** 133,135 ****
--- 133,195 ----
  \.
  
  copy copytest3 to stdout csv header;
+ 
+ -- copy raw
+ CREATE TABLE x(a bytea);
+ INSERT INTO x VALUES('\x41484f4a0a');
+ SELECT length(a) FROM x;
+ 
+ INSERT INTO x VALUES('\x41484f4a0a');
+ 
+ -- should to fail
+ COPY (SELECT a,a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+ COPY (SELECT a FROM x) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+ 
+ -- should be ok
+ COPY (SELECT a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+ TRUNCATE x;
+ COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw);
+ SELECT length(a) FROM x;
+ COPY x TO stdout (FORMAT raw);
+ 
+ TRUNCATE x;
+ 
+ \COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw)
+ SELECT length(a) FROM x;
+ COPY x TO stdout (FORMAT raw);
+ 
+ \COPY x TO '@abs_builddir@/results/raw2.data' (FORMAT raw)
+ TRUNCATE x;
+ 
+ \COPY x FROM '@abs_builddir@/results/raw2.data' (FORMAT raw)
+ SELECT length(a) FROM x;
+ COPY x TO stdout (FORMAT raw);
+ 
+ -- test big file
+ TRUNCATE x;
+ -- use different mechanism for load to bytea
+ \lo_import @abs_builddir@/data/hash.data
+ \set lo_oid :LASTOID
+ INSERT INTO x VALUES(lo_get(:lo_oid));
+ \lo_unlink :lo_oid
+ 
+ COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw);
+ \COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw)
+ 
+ SELECT md5(a), length(a) FROM x;
+ 
+ TRUNCATE x;
+ COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw);
+ COPY x TO '@abs_builddir@/results/hash2.data' (FORMAT raw);
+ \COPY x TO '@abs_builddir@/results/hash3.data' (FORMAT raw)
+ 
+ -- read again
+ COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw);
+ \COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw)
+ -- cross
+ COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw);
+ \COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw)
+ 
+ SELECT md5(a), length(a) FROM x;
+ 
+ DROP TABLE x;
diff --git a/src/test/regress/output/copy.source b/src/test/regress/output/copy.source
new file mode 100644
index b7e372d..f555f58
*** a/src/test/regress/output/copy.source
--- b/src/test/regress/output/copy.source
*************** copy copytest3 to stdout csv header;
*** 95,97 ****
--- 95,183 ----
  c1,"col with , comma","col with "" quote"
  1,a,1
  2,b,2
+ -- copy raw
+ CREATE TABLE x(a bytea);
+ INSERT INTO x VALUES('\x41484f4a0a');
+ SELECT length(a) FROM x;
+  length 
+ --------
+       5
+ (1 row)
+ 
+ INSERT INTO x VALUES('\x41484f4a0a');
+ -- should to fail
+ COPY (SELECT a,a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+ ERROR:  only single column result is allowed in RAW mode
+ COPY (SELECT a FROM x) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+ ERROR:  only single row result is allowed in RAW mode
+ -- should be ok
+ COPY (SELECT a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+ TRUNCATE x;
+ COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw);
+ SELECT length(a) FROM x;
+  length 
+ --------
+       5
+ (1 row)
+ 
+ COPY x TO stdout (FORMAT raw);
+ AHOJ
+ TRUNCATE x;
+ \COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw)
+ SELECT length(a) FROM x;
+  length 
+ --------
+       5
+ (1 row)
+ 
+ COPY x TO stdout (FORMAT raw);
+ AHOJ
+ \COPY x TO '@abs_builddir@/results/raw2.data' (FORMAT raw)
+ TRUNCATE x;
+ \COPY x FROM '@abs_builddir@/results/raw2.data' (FORMAT raw)
+ SELECT length(a) FROM x;
+  length 
+ --------
+       5
+ (1 row)
+ 
+ COPY x TO stdout (FORMAT raw);
+ AHOJ
+ -- test big file
+ TRUNCATE x;
+ -- use different mechanism for load to bytea
+ \lo_import @abs_builddir@/data/hash.data
+ \set lo_oid :LASTOID
+ INSERT INTO x VALUES(lo_get(:lo_oid));
+ \lo_unlink :lo_oid
+ COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw);
+ \COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw)
+ SELECT md5(a), length(a) FROM x;
+                md5                | length 
+ ----------------------------------+--------
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+ (3 rows)
+ 
+ TRUNCATE x;
+ COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw);
+ COPY x TO '@abs_builddir@/results/hash2.data' (FORMAT raw);
+ \COPY x TO '@abs_builddir@/results/hash3.data' (FORMAT raw)
+ -- read again
+ COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw);
+ \COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw)
+ -- cross
+ COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw);
+ \COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw)
+ SELECT md5(a), length(a) FROM x;
+                md5                | length 
+ ----------------------------------+--------
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+ (5 rows)
+ 
+ DROP TABLE x;
diff --git a/src/test/regress/sql/copy2.sql b/src/test/regress/sql/copy2.sql
new file mode 100644
index 39a9deb..e5703a5
*** a/src/test/regress/sql/copy2.sql
--- b/src/test/regress/sql/copy2.sql
*************** DROP FUNCTION truncate_in_subxact();
*** 333,335 ****
--- 333,348 ----
  DROP TABLE x, y;
  DROP FUNCTION fn_x_before();
  DROP FUNCTION fn_x_after();
+ 
+ CREATE TABLE x(a bytea);
+ INSERT INTO x VALUES('\x41484f4a0a');
+ INSERT INTO x VALUES('\x41484f4a0a');
+ 
+ -- should to fail
+ COPY (SELECT a,a FROM x LIMIT 1) TO STDOUT (FORMAT raw);
+ COPY (SELECT a FROM x) TO STDOUT (FORMAT raw);
+ 
+ -- should be ok
+ COPY (SELECT a FROM x LIMIT 1) TO STDOUT (FORMAT raw);
+ 
+ DROP TABLE x;

diff --git a/doc/src/sgml/ref/copy.sgml b/doc/src/sgml/ref/copy.sgml
new file mode 100644
index 07e2f45..68fbfd8
*** a/doc/src/sgml/ref/copy.sgml
--- b/doc/src/sgml/ref/copy.sgml
*************** COPY { <replaceable class="parameter">ta
*** 197,203 ****
        Selects the data format to be read or written:
        <literal>text</>,
        <literal>csv</> (Comma Separated Values),
!       or <literal>binary</>.
        The default is <literal>text</>.
       </para>
      </listitem>
--- 197,203 ----
        Selects the data format to be read or written:
        <literal>text</>,
        <literal>csv</> (Comma Separated Values),
!       <literal>binary</> or <literal>raw</literal>.
        The default is <literal>text</>.
       </para>
      </listitem>
*************** OIDs to be shown as null if that ever pr
*** 888,893 ****
--- 888,925 ----
      </para>
     </refsect3>
    </refsect2>
+ 
+   <refsect2>
+      <title>Raw Format</title>
+ 
+    <para>
+     The <literal>raw</literal> format option causes all data to be
+     stored/read as binary format rather than as text. It shares format
+     for data with <literal>binary</literal> format. This format doesn't
+     use any metadata - only row data in network byte order are exported
+     or imported.
+    </para>
+ 
+    <para>
+     Because this format doesn't support any delimiter, only one value
+     can be exported or imported. NULL values are not allowed.
+    </para>
+    <para>
+     The <literal>raw</literal> format can be used for export or import
+     bytea values.
+ <programlisting>
+ COPY images(data) FROM '/usr1/proj/img/01.jpg' (FORMAT raw);
+ </programlisting>
+     It can be used successfully for export XML in different encoding
+     or import valid XML document with any supported encoding:
+ <screen><![CDATA[
+ SET client_encoding TO latin2;
+ 
+ COPY (SELECT xmlelement(NAME data, 'Hello')) TO stdout (FORMAT raw);
+ <?xml version="1.0" encoding="LATIN2"?><data>Hello</data>
+ ]]></screen>
+    </para>
+   </refsect2>
   </refsect1>
  
   <refsect1>
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
new file mode 100644
index 3201476..beb9152
*** a/src/backend/commands/copy.c
--- b/src/backend/commands/copy.c
*************** typedef enum EolType
*** 89,94 ****
--- 89,99 ----
   * it's faster to make useless comparisons to trailing bytes than it is to
   * invoke pg_encoding_mblen() to skip over them. encoding_embeds_ascii is TRUE
   * when we have to do it the hard way.
+  *
+  * COPY supports three modes: text, binary and raw. The text format is plain
+  * text multiline format with specified delimiter. The binary format holds
+  * metadata (numbers, sizes) and data. The raw format holds data only and
+  * only one non NULL value can be processed.
   */
  typedef struct CopyStateData
  {
*************** typedef struct CopyStateData
*** 110,115 ****
--- 115,121 ----
  	char	   *filename;		/* filename, or NULL for STDIN/STDOUT */
  	bool		is_program;		/* is 'filename' a program to popen? */
  	bool		binary;			/* binary format? */
+ 	bool		raw;			/* required raw binary? */
  	bool		oids;			/* include OIDs? */
  	bool		freeze;			/* freeze rows on loading? */
  	bool		csv_mode;		/* Comma Separated Value format? */
*************** typedef struct CopyStateData
*** 199,204 ****
--- 205,213 ----
  	char	   *raw_buf;
  	int			raw_buf_index;	/* next byte to process */
  	int			raw_buf_len;	/* total # of bytes stored */
+ 
+ 	/* field for RAW mode */
+ 	bool		row_processed;		/* true, when first row was processed */
  } CopyStateData;
  
  /* DestReceiver for COPY (query) TO */
*************** SendCopyBegin(CopyState cstate)
*** 342,350 ****
  		/* new way */
  		StringInfoData buf;
  		int			natts = list_length(cstate->attnumlist);
! 		int16		format = (cstate->binary ? 1 : 0);
  		int			i;
  
  		pq_beginmessage(&buf, 'H');
  		pq_sendbyte(&buf, format);		/* overall format */
  		pq_sendint(&buf, natts, 2);
--- 351,366 ----
  		/* new way */
  		StringInfoData buf;
  		int			natts = list_length(cstate->attnumlist);
! 		int16		format;
  		int			i;
  
+ 		if (cstate->raw)
+ 			format = 2;
+ 		else if (cstate->binary)
+ 			format = 1;
+ 		else
+ 			format = 0;
+ 
  		pq_beginmessage(&buf, 'H');
  		pq_sendbyte(&buf, format);		/* overall format */
  		pq_sendint(&buf, natts, 2);
*************** SendCopyBegin(CopyState cstate)
*** 356,362 ****
  	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
  	{
  		/* old way */
! 		if (cstate->binary)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
--- 372,378 ----
  	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
  	{
  		/* old way */
! 		if (cstate->binary && cstate->raw)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
*************** SendCopyBegin(CopyState cstate)
*** 368,374 ****
  	else
  	{
  		/* very old way */
! 		if (cstate->binary)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
--- 384,390 ----
  	else
  	{
  		/* very old way */
! 		if (cstate->binary && cstate->raw)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
*************** ReceiveCopyBegin(CopyState cstate)
*** 387,395 ****
  		/* new way */
  		StringInfoData buf;
  		int			natts = list_length(cstate->attnumlist);
! 		int16		format = (cstate->binary ? 1 : 0);
  		int			i;
  
  		pq_beginmessage(&buf, 'G');
  		pq_sendbyte(&buf, format);		/* overall format */
  		pq_sendint(&buf, natts, 2);
--- 403,418 ----
  		/* new way */
  		StringInfoData buf;
  		int			natts = list_length(cstate->attnumlist);
! 		int16		format;
  		int			i;
  
+ 		if (cstate->raw)
+ 			format = 2;
+ 		else if (cstate->binary)
+ 			format = 1;
+ 		else
+ 			format = 0;
+ 
  		pq_beginmessage(&buf, 'G');
  		pq_sendbyte(&buf, format);		/* overall format */
  		pq_sendint(&buf, natts, 2);
*************** ReceiveCopyBegin(CopyState cstate)
*** 402,408 ****
  	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
  	{
  		/* old way */
! 		if (cstate->binary)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
--- 425,431 ----
  	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
  	{
  		/* old way */
! 		if (cstate->binary || cstate->raw)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
*************** ReceiveCopyBegin(CopyState cstate)
*** 414,420 ****
  	else
  	{
  		/* very old way */
! 		if (cstate->binary)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
--- 437,443 ----
  	else
  	{
  		/* very old way */
! 		if (cstate->binary || cstate->raw)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
*************** CopySendEndOfRow(CopyState cstate)
*** 482,488 ****
  	switch (cstate->copy_dest)
  	{
  		case COPY_FILE:
! 			if (!cstate->binary)
  			{
  				/* Default line termination depends on platform */
  #ifndef WIN32
--- 505,511 ----
  	switch (cstate->copy_dest)
  	{
  		case COPY_FILE:
! 			if (!cstate->binary && !cstate->raw)
  			{
  				/* Default line termination depends on platform */
  #ifndef WIN32
*************** CopySendEndOfRow(CopyState cstate)
*** 527,533 ****
  			break;
  		case COPY_OLD_FE:
  			/* The FE/BE protocol uses \n as newline for all platforms */
! 			if (!cstate->binary)
  				CopySendChar(cstate, '\n');
  
  			if (pq_putbytes(fe_msgbuf->data, fe_msgbuf->len))
--- 550,556 ----
  			break;
  		case COPY_OLD_FE:
  			/* The FE/BE protocol uses \n as newline for all platforms */
! 			if (!cstate->binary && !cstate->raw)
  				CopySendChar(cstate, '\n');
  
  			if (pq_putbytes(fe_msgbuf->data, fe_msgbuf->len))
*************** CopySendEndOfRow(CopyState cstate)
*** 540,546 ****
  			break;
  		case COPY_NEW_FE:
  			/* The FE/BE protocol uses \n as newline for all platforms */
! 			if (!cstate->binary)
  				CopySendChar(cstate, '\n');
  
  			/* Dump the accumulated row as one CopyData message */
--- 563,569 ----
  			break;
  		case COPY_NEW_FE:
  			/* The FE/BE protocol uses \n as newline for all platforms */
! 			if (!cstate->binary && !cstate->raw)
  				CopySendChar(cstate, '\n');
  
  			/* Dump the accumulated row as one CopyData message */
*************** CopyGetData(CopyState cstate, void *data
*** 597,602 ****
--- 620,626 ----
  			bytesread = minread;
  			break;
  		case COPY_NEW_FE:
+ 
  			while (maxread > 0 && bytesread < minread && !cstate->fe_eof)
  			{
  				int			avail;
*************** CopyGetData(CopyState cstate, void *data
*** 619,624 ****
--- 643,649 ----
  								(errcode(ERRCODE_CONNECTION_FAILURE),
  								 errmsg("unexpected EOF on client connection with an open transaction")));
  					RESUME_CANCEL_INTERRUPTS();
+ 
  					switch (mtype)
  					{
  						case 'd':		/* CopyData */
*************** CopyLoadRawBuf(CopyState cstate)
*** 766,771 ****
--- 791,827 ----
  	return (inbytes > 0);
  }
  
+ /*
+  * CopyLoadallRawBuf load all file into raw_buf.
+  *
+  * It is used for reading content in raw mode. If original RAW_BUF_SIZE is not
+  * enough, the buffer is enlarged.
+  */
+ static void
+ CopyLoadallRawBuf(CopyState cstate)
+ {
+ 	int			nbytes = 0;
+ 	int			inbytes;
+ 	Size			raw_buf_size = RAW_BUF_SIZE;
+ 
+ 	do
+ 	{
+ 		/* hold enough space for one data packet */
+ 		if ((raw_buf_size - nbytes - 1) < 8 * 1024)
+ 		{
+ 			raw_buf_size += RAW_BUF_SIZE;
+ 			cstate->raw_buf = repalloc(cstate->raw_buf, raw_buf_size);
+ 		}
+ 
+ 		inbytes = CopyGetData(cstate, cstate->raw_buf + nbytes, 1, raw_buf_size - nbytes - 1);
+ 		nbytes += inbytes;
+ 	}
+ 	while (inbytes > 0);
+ 
+ 	cstate->raw_buf[nbytes] = '\0';
+ 	cstate->raw_buf_index = 0;
+ 	cstate->raw_buf_len = nbytes;
+ }
  
  /*
   *	 DoCopy executes the SQL COPY statement
*************** ProcessCopyOptions(CopyState cstate,
*** 1013,1018 ****
--- 1069,1076 ----
  				cstate->csv_mode = true;
  			else if (strcmp(fmt, "binary") == 0)
  				cstate->binary = true;
+ 			else if (strcmp(fmt, "raw") == 0)
+ 				cstate->raw = true;
  			else
  				ereport(ERROR,
  						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
*************** ProcessCopyOptions(CopyState cstate,
*** 1162,1176 ****
  	 * Check for incompatible options (must do these two before inserting
  	 * defaults)
  	 */
! 	if (cstate->binary && cstate->delim)
  		ereport(ERROR,
  				(errcode(ERRCODE_SYNTAX_ERROR),
! 				 errmsg("cannot specify DELIMITER in BINARY mode")));
  
! 	if (cstate->binary && cstate->null_print)
  		ereport(ERROR,
  				(errcode(ERRCODE_SYNTAX_ERROR),
! 				 errmsg("cannot specify NULL in BINARY mode")));
  
  	/* Set defaults for omitted options */
  	if (!cstate->delim)
--- 1220,1239 ----
  	 * Check for incompatible options (must do these two before inserting
  	 * defaults)
  	 */
! 	if ((cstate->binary || cstate->raw) && cstate->delim)
  		ereport(ERROR,
  				(errcode(ERRCODE_SYNTAX_ERROR),
! 				 errmsg("cannot specify DELIMITER in BINARY or RAW mode")));
  
! 	if ((cstate->binary || cstate->raw) && cstate->null_print)
  		ereport(ERROR,
  				(errcode(ERRCODE_SYNTAX_ERROR),
! 				 errmsg("cannot specify NULL in BINARY or RAW mode")));
! 
! 	if (cstate->raw && cstate->oids)
! 		ereport(ERROR,
! 				(errcode(ERRCODE_SYNTAX_ERROR),
! 				 errmsg("cannot specify OIDS in RAW mode")));
  
  	/* Set defaults for omitted options */
  	if (!cstate->delim)
*************** BeginCopy(bool is_from,
*** 1608,1613 ****
--- 1671,1690 ----
  		}
  	}
  
+ 	/*
+ 	 * Initializaze the field "row_processed" for one row output in RAW mode,
+ 	 * and ensure only one output column.
+ 	 */
+ 	if (cstate->raw)
+ 	{
+ 		cstate->row_processed = false;
+ 
+ 		if (num_phys_attrs > 1)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 					 errmsg("only single column result is allowed in RAW mode")));
+ 	}
+ 
  	/* Use client encoding when ENCODING option is not specified. */
  	if (cstate->file_encoding < 0)
  		cstate->file_encoding = pg_get_client_encoding();
*************** CopyTo(CopyState cstate)
*** 1876,1882 ****
  		Oid			out_func_oid;
  		bool		isvarlena;
  
! 		if (cstate->binary)
  			getTypeBinaryOutputInfo(attr[attnum - 1]->atttypid,
  									&out_func_oid,
  									&isvarlena);
--- 1953,1959 ----
  		Oid			out_func_oid;
  		bool		isvarlena;
  
! 		if (cstate->binary || cstate->raw)
  			getTypeBinaryOutputInfo(attr[attnum - 1]->atttypid,
  									&out_func_oid,
  									&isvarlena);
*************** CopyTo(CopyState cstate)
*** 1915,1921 ****
  		tmp = 0;
  		CopySendInt32(cstate, tmp);
  	}
! 	else
  	{
  		/*
  		 * For non-binary copy, we need to convert null_print to file
--- 1992,1998 ----
  		tmp = 0;
  		CopySendInt32(cstate, tmp);
  	}
! 	else if (!cstate->raw)
  	{
  		/*
  		 * For non-binary copy, we need to convert null_print to file
*************** CopyTo(CopyState cstate)
*** 1983,1989 ****
  	else
  	{
  		/* run the plan --- the dest receiver will send tuples */
! 		ExecutorRun(cstate->queryDesc, ForwardScanDirection, 0L);
  		processed = ((DR_copy *) cstate->queryDesc->dest)->processed;
  	}
  
--- 2060,2066 ----
  	else
  	{
  		/* run the plan --- the dest receiver will send tuples */
! 		ExecutorRun(cstate->queryDesc, ForwardScanDirection, cstate->raw ? 2L : 0L);
  		processed = ((DR_copy *) cstate->queryDesc->dest)->processed;
  	}
  
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 2027,2032 ****
--- 2104,2117 ----
  			CopySendInt32(cstate, tupleOid);
  		}
  	}
+ 	else if (cstate->raw)
+ 	{
+ 		if (cstate->row_processed)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_TOO_MANY_ROWS),
+ 					 errmsg("only single row result is allowed in RAW mode")));
+ 		cstate->row_processed = true;
+ 	}
  	else
  	{
  		/* Text format has no per-tuple header, but send OID if wanted */
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 2046,2052 ****
  		Datum		value = values[attnum - 1];
  		bool		isnull = nulls[attnum - 1];
  
! 		if (!cstate->binary)
  		{
  			if (need_delim)
  				CopySendChar(cstate, cstate->delim[0]);
--- 2131,2137 ----
  		Datum		value = values[attnum - 1];
  		bool		isnull = nulls[attnum - 1];
  
! 		if (!cstate->binary && !cstate->raw)
  		{
  			if (need_delim)
  				CopySendChar(cstate, cstate->delim[0]);
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 2055,2068 ****
  
  		if (isnull)
  		{
! 			if (!cstate->binary)
  				CopySendString(cstate, cstate->null_print_client);
  			else
  				CopySendInt32(cstate, -1);
  		}
  		else
  		{
! 			if (!cstate->binary)
  			{
  				string = OutputFunctionCall(&out_functions[attnum - 1],
  											value);
--- 2140,2171 ----
  
  		if (isnull)
  		{
! 			if (cstate->raw)
! 					ereport(ERROR,
! 						(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
! 						  errmsg("cannot to copy NULL value in RAW mode.")));
! 			else if (!cstate->binary)
  				CopySendString(cstate, cstate->null_print_client);
  			else
  				CopySendInt32(cstate, -1);
  		}
  		else
  		{
! 			if (cstate->binary || cstate->raw)
! 			{
! 				bytea	   *outputbytes;
! 
! 				outputbytes = SendFunctionCall(&out_functions[attnum - 1],
! 											   value);
! 
! 				/* send the size only in binary mode */
! 				if (cstate->binary)
! 					CopySendInt32(cstate, VARSIZE(outputbytes) - VARHDRSZ);
! 
! 				CopySendData(cstate, VARDATA(outputbytes),
! 							 VARSIZE(outputbytes) - VARHDRSZ);
! 			}
! 			else
  			{
  				string = OutputFunctionCall(&out_functions[attnum - 1],
  											value);
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 2073,2088 ****
  				else
  					CopyAttributeOutText(cstate, string);
  			}
- 			else
- 			{
- 				bytea	   *outputbytes;
- 
- 				outputbytes = SendFunctionCall(&out_functions[attnum - 1],
- 											   value);
- 				CopySendInt32(cstate, VARSIZE(outputbytes) - VARHDRSZ);
- 				CopySendData(cstate, VARDATA(outputbytes),
- 							 VARSIZE(outputbytes) - VARHDRSZ);
- 			}
  		}
  	}
  
--- 2176,2181 ----
*************** BeginCopyFrom(Relation rel,
*** 2712,2718 ****
  			continue;
  
  		/* Fetch the input function and typioparam info */
! 		if (cstate->binary)
  			getTypeBinaryInputInfo(attr[attnum - 1]->atttypid,
  								   &in_func_oid, &typioparams[attnum - 1]);
  		else
--- 2805,2811 ----
  			continue;
  
  		/* Fetch the input function and typioparam info */
! 		if (cstate->binary || cstate->raw)
  			getTypeBinaryInputInfo(attr[attnum - 1]->atttypid,
  								   &in_func_oid, &typioparams[attnum - 1]);
  		else
*************** BeginCopyFrom(Relation rel,
*** 2811,2817 ****
  		}
  	}
  
! 	if (!cstate->binary)
  	{
  		/* must rely on user to tell us... */
  		cstate->file_has_oids = cstate->oids;
--- 2904,2910 ----
  		}
  	}
  
! 	if (!cstate->binary || cstate->raw)
  	{
  		/* must rely on user to tell us... */
  		cstate->file_has_oids = cstate->oids;
*************** BeginCopyFrom(Relation rel,
*** 2863,2869 ****
  	}
  
  	/* create workspace for CopyReadAttributes results */
! 	if (!cstate->binary)
  	{
  		AttrNumber	attr_count = list_length(cstate->attnumlist);
  		int			nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
--- 2956,2962 ----
  	}
  
  	/* create workspace for CopyReadAttributes results */
! 	if (!cstate->binary && !cstate->raw)
  	{
  		AttrNumber	attr_count = list_length(cstate->attnumlist);
  		int			nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
*************** NextCopyFrom(CopyState cstate, ExprConte
*** 2968,2975 ****
  	MemSet(values, 0, num_phys_attrs * sizeof(Datum));
  	MemSet(nulls, true, num_phys_attrs * sizeof(bool));
  
! 	if (!cstate->binary)
  	{
  		char	  **field_strings;
  		ListCell   *cur;
  		int			fldct;
--- 3061,3180 ----
  	MemSet(values, 0, num_phys_attrs * sizeof(Datum));
  	MemSet(nulls, true, num_phys_attrs * sizeof(bool));
  
! 	if (cstate->binary)
  	{
+ 		int16		fld_count;
+ 		ListCell   *cur;
+ 
+ 		cstate->cur_lineno++;
+ 
+ 		if (!CopyGetInt16(cstate, &fld_count))
+ 		{
+ 			/* EOF detected (end of file, or protocol-level EOF) */
+ 			return false;
+ 		}
+ 
+ 		if (fld_count == -1)
+ 		{
+ 			/*
+ 			 * Received EOF marker.  In a V3-protocol copy, wait for the
+ 			 * protocol-level EOF, and complain if it doesn't come
+ 			 * immediately.  This ensures that we correctly handle CopyFail,
+ 			 * if client chooses to send that now.
+ 			 *
+ 			 * Note that we MUST NOT try to read more data in an old-protocol
+ 			 * copy, since there is no protocol-level EOF marker then.  We
+ 			 * could go either way for copy from file, but choose to throw
+ 			 * error if there's data after the EOF marker, for consistency
+ 			 * with the new-protocol case.
+ 			 */
+ 			char		dummy;
+ 
+ 			if (cstate->copy_dest != COPY_OLD_FE &&
+ 				CopyGetData(cstate, &dummy, 1, 1) > 0)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
+ 						 errmsg("received copy data after EOF marker")));
+ 			return false;
+ 		}
+ 
+ 		if (fld_count != attr_count)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
+ 					 errmsg("row field count is %d, expected %d",
+ 							(int) fld_count, attr_count)));
+ 
+ 		if (file_has_oids)
+ 		{
+ 			Oid			loaded_oid;
+ 
+ 			cstate->cur_attname = "oid";
+ 			loaded_oid =
+ 				DatumGetObjectId(CopyReadBinaryAttribute(cstate,
+ 														 0,
+ 													&cstate->oid_in_function,
+ 													  cstate->oid_typioparam,
+ 														 -1,
+ 														 &isnull));
+ 			if (isnull || loaded_oid == InvalidOid)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
+ 						 errmsg("invalid OID in COPY data")));
+ 			cstate->cur_attname = NULL;
+ 			if (cstate->oids && tupleOid != NULL)
+ 				*tupleOid = loaded_oid;
+ 		}
+ 
+ 		i = 0;
+ 		foreach(cur, cstate->attnumlist)
+ 		{
+ 			int			attnum = lfirst_int(cur);
+ 			int			m = attnum - 1;
+ 
+ 			cstate->cur_attname = NameStr(attr[m]->attname);
+ 			i++;
+ 			values[m] = CopyReadBinaryAttribute(cstate,
+ 												i,
+ 												&in_functions[m],
+ 												typioparams[m],
+ 												attr[m]->atttypmod,
+ 												&nulls[m]);
+ 			cstate->cur_attname = NULL;
+ 		}
+ 	}
+ 	else if (cstate->raw)
+ 	{
+ 		if (cstate->row_processed)
+ 			return false;
+ 
+ 		CopyLoadallRawBuf(cstate);
+ 		cstate->cur_attname = NameStr(attr[0]->attname);
+ 
+ 		if (cstate->attribute_buf.data != NULL)
+ 			pfree(cstate->attribute_buf.data);
+ 
+ 		cstate->attribute_buf.data = cstate->raw_buf;
+ 		cstate->attribute_buf.len = cstate->raw_buf_len;
+ 		cstate->attribute_buf.cursor = 0;
+ 
+ 		cstate->raw_buf = NULL;
+ 
+ 		/* Call the column type's binary input converter */
+ 		values[0] = ReceiveFunctionCall(&in_functions[0], &cstate->attribute_buf,
+ 								 typioparams[0], attr[0]->atttypmod);
+ 		nulls[0] = false;
+ 
+ 		/* Trouble if it didn't eat the whole buffer */
+ 		if (cstate->attribute_buf.cursor != cstate->attribute_buf.len)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
+ 					 errmsg("incorrect binary data format")));
+ 
+ 		cstate->row_processed = true;
+ 	}
+ 	else
+ 	{
+ 		/* text */
  		char	  **field_strings;
  		ListCell   *cur;
  		int			fldct;
*************** NextCopyFrom(CopyState cstate, ExprConte
*** 3074,3161 ****
  
  		Assert(fieldno == nfields);
  	}
- 	else
- 	{
- 		/* binary */
- 		int16		fld_count;
- 		ListCell   *cur;
- 
- 		cstate->cur_lineno++;
- 
- 		if (!CopyGetInt16(cstate, &fld_count))
- 		{
- 			/* EOF detected (end of file, or protocol-level EOF) */
- 			return false;
- 		}
- 
- 		if (fld_count == -1)
- 		{
- 			/*
- 			 * Received EOF marker.  In a V3-protocol copy, wait for the
- 			 * protocol-level EOF, and complain if it doesn't come
- 			 * immediately.  This ensures that we correctly handle CopyFail,
- 			 * if client chooses to send that now.
- 			 *
- 			 * Note that we MUST NOT try to read more data in an old-protocol
- 			 * copy, since there is no protocol-level EOF marker then.  We
- 			 * could go either way for copy from file, but choose to throw
- 			 * error if there's data after the EOF marker, for consistency
- 			 * with the new-protocol case.
- 			 */
- 			char		dummy;
- 
- 			if (cstate->copy_dest != COPY_OLD_FE &&
- 				CopyGetData(cstate, &dummy, 1, 1) > 0)
- 				ereport(ERROR,
- 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
- 						 errmsg("received copy data after EOF marker")));
- 			return false;
- 		}
- 
- 		if (fld_count != attr_count)
- 			ereport(ERROR,
- 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
- 					 errmsg("row field count is %d, expected %d",
- 							(int) fld_count, attr_count)));
- 
- 		if (file_has_oids)
- 		{
- 			Oid			loaded_oid;
- 
- 			cstate->cur_attname = "oid";
- 			loaded_oid =
- 				DatumGetObjectId(CopyReadBinaryAttribute(cstate,
- 														 0,
- 													&cstate->oid_in_function,
- 													  cstate->oid_typioparam,
- 														 -1,
- 														 &isnull));
- 			if (isnull || loaded_oid == InvalidOid)
- 				ereport(ERROR,
- 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
- 						 errmsg("invalid OID in COPY data")));
- 			cstate->cur_attname = NULL;
- 			if (cstate->oids && tupleOid != NULL)
- 				*tupleOid = loaded_oid;
- 		}
- 
- 		i = 0;
- 		foreach(cur, cstate->attnumlist)
- 		{
- 			int			attnum = lfirst_int(cur);
- 			int			m = attnum - 1;
- 
- 			cstate->cur_attname = NameStr(attr[m]->attname);
- 			i++;
- 			values[m] = CopyReadBinaryAttribute(cstate,
- 												i,
- 												&in_functions[m],
- 												typioparams[m],
- 												attr[m]->atttypmod,
- 												&nulls[m]);
- 			cstate->cur_attname = NULL;
- 		}
- 	}
  
  	/*
  	 * Now compute and insert any defaults available for the columns not
--- 3279,3284 ----
diff --git a/src/test/regress/expected/copy2.out b/src/test/regress/expected/copy2.out
new file mode 100644
index 5f6260a..90d2aa5
*** a/src/test/regress/expected/copy2.out
--- b/src/test/regress/expected/copy2.out
*************** DROP FUNCTION truncate_in_subxact();
*** 466,468 ****
--- 466,481 ----
  DROP TABLE x, y;
  DROP FUNCTION fn_x_before();
  DROP FUNCTION fn_x_after();
+ CREATE TABLE x(a bytea);
+ INSERT INTO x VALUES('\x41484f4a0a');
+ INSERT INTO x VALUES('\x41484f4a0a');
+ -- should to fail
+ COPY (SELECT a,a FROM x LIMIT 1) TO STDOUT (FORMAT raw);
+ ERROR:  only single column result is allowed in RAW mode
+ COPY (SELECT a FROM x) TO STDOUT (FORMAT raw);
+ AHOJ
+ ERROR:  only single row result is allowed in RAW mode
+ -- should be ok
+ COPY (SELECT a FROM x LIMIT 1) TO STDOUT (FORMAT raw);
+ AHOJ
+ DROP TABLE x;
diff --git a/src/test/regress/input/copy.source b/src/test/regress/input/copy.source
new file mode 100644
index cb13606..d351b43
*** a/src/test/regress/input/copy.source
--- b/src/test/regress/input/copy.source
*************** this is just a line full of junk that wo
*** 133,135 ****
--- 133,195 ----
  \.
  
  copy copytest3 to stdout csv header;
+ 
+ -- copy raw
+ CREATE TABLE x(a bytea);
+ INSERT INTO x VALUES('\x41484f4a0a');
+ SELECT length(a) FROM x;
+ 
+ INSERT INTO x VALUES('\x41484f4a0a');
+ 
+ -- should to fail
+ COPY (SELECT a,a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+ COPY (SELECT a FROM x) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+ 
+ -- should be ok
+ COPY (SELECT a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+ TRUNCATE x;
+ COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw);
+ SELECT length(a) FROM x;
+ COPY x TO stdout (FORMAT raw);
+ 
+ TRUNCATE x;
+ 
+ \COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw)
+ SELECT length(a) FROM x;
+ COPY x TO stdout (FORMAT raw);
+ 
+ \COPY x TO '@abs_builddir@/results/raw2.data' (FORMAT raw)
+ TRUNCATE x;
+ 
+ \COPY x FROM '@abs_builddir@/results/raw2.data' (FORMAT raw)
+ SELECT length(a) FROM x;
+ COPY x TO stdout (FORMAT raw);
+ 
+ -- test big file
+ TRUNCATE x;
+ -- use different mechanism for load to bytea
+ \lo_import @abs_builddir@/data/hash.data
+ \set lo_oid :LASTOID
+ INSERT INTO x VALUES(lo_get(:lo_oid));
+ \lo_unlink :lo_oid
+ 
+ COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw);
+ \COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw)
+ 
+ SELECT md5(a), length(a) FROM x;
+ 
+ TRUNCATE x;
+ COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw);
+ COPY x TO '@abs_builddir@/results/hash2.data' (FORMAT raw);
+ \COPY x TO '@abs_builddir@/results/hash3.data' (FORMAT raw)
+ 
+ -- read again
+ COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw);
+ \COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw)
+ -- cross
+ COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw);
+ \COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw)
+ 
+ SELECT md5(a), length(a) FROM x;
+ 
+ DROP TABLE x;
diff --git a/src/test/regress/output/copy.source b/src/test/regress/output/copy.source
new file mode 100644
index b7e372d..f555f58
*** a/src/test/regress/output/copy.source
--- b/src/test/regress/output/copy.source
*************** copy copytest3 to stdout csv header;
*** 95,97 ****
--- 95,183 ----
  c1,"col with , comma","col with "" quote"
  1,a,1
  2,b,2
+ -- copy raw
+ CREATE TABLE x(a bytea);
+ INSERT INTO x VALUES('\x41484f4a0a');
+ SELECT length(a) FROM x;
+  length 
+ --------
+       5
+ (1 row)
+ 
+ INSERT INTO x VALUES('\x41484f4a0a');
+ -- should to fail
+ COPY (SELECT a,a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+ ERROR:  only single column result is allowed in RAW mode
+ COPY (SELECT a FROM x) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+ ERROR:  only single row result is allowed in RAW mode
+ -- should be ok
+ COPY (SELECT a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw);
+ TRUNCATE x;
+ COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw);
+ SELECT length(a) FROM x;
+  length 
+ --------
+       5
+ (1 row)
+ 
+ COPY x TO stdout (FORMAT raw);
+ AHOJ
+ TRUNCATE x;
+ \COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw)
+ SELECT length(a) FROM x;
+  length 
+ --------
+       5
+ (1 row)
+ 
+ COPY x TO stdout (FORMAT raw);
+ AHOJ
+ \COPY x TO '@abs_builddir@/results/raw2.data' (FORMAT raw)
+ TRUNCATE x;
+ \COPY x FROM '@abs_builddir@/results/raw2.data' (FORMAT raw)
+ SELECT length(a) FROM x;
+  length 
+ --------
+       5
+ (1 row)
+ 
+ COPY x TO stdout (FORMAT raw);
+ AHOJ
+ -- test big file
+ TRUNCATE x;
+ -- use different mechanism for load to bytea
+ \lo_import @abs_builddir@/data/hash.data
+ \set lo_oid :LASTOID
+ INSERT INTO x VALUES(lo_get(:lo_oid));
+ \lo_unlink :lo_oid
+ COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw);
+ \COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw)
+ SELECT md5(a), length(a) FROM x;
+                md5                | length 
+ ----------------------------------+--------
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+ (3 rows)
+ 
+ TRUNCATE x;
+ COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw);
+ COPY x TO '@abs_builddir@/results/hash2.data' (FORMAT raw);
+ \COPY x TO '@abs_builddir@/results/hash3.data' (FORMAT raw)
+ -- read again
+ COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw);
+ \COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw)
+ -- cross
+ COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw);
+ \COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw)
+ SELECT md5(a), length(a) FROM x;
+                md5                | length 
+ ----------------------------------+--------
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+ (5 rows)
+ 
+ DROP TABLE x;
diff --git a/src/test/regress/sql/copy2.sql b/src/test/regress/sql/copy2.sql
new file mode 100644
index 39a9deb..e5703a5
*** a/src/test/regress/sql/copy2.sql
--- b/src/test/regress/sql/copy2.sql
*************** DROP FUNCTION truncate_in_subxact();
*** 333,335 ****
--- 333,348 ----
  DROP TABLE x, y;
  DROP FUNCTION fn_x_before();
  DROP FUNCTION fn_x_after();
+ 
+ CREATE TABLE x(a bytea);
+ INSERT INTO x VALUES('\x41484f4a0a');
+ INSERT INTO x VALUES('\x41484f4a0a');
+ 
+ -- should to fail
+ COPY (SELECT a,a FROM x LIMIT 1) TO STDOUT (FORMAT raw);
+ COPY (SELECT a FROM x) TO STDOUT (FORMAT raw);
+ 
+ -- should be ok
+ COPY (SELECT a FROM x LIMIT 1) TO STDOUT (FORMAT raw);
+ 
+ DROP TABLE x;

diff --git a/doc/src/sgml/ref/copy.sgml b/doc/src/sgml/ref/copy.sgml
new file mode 100644
index 07e2f45..68fbfd8
*** a/doc/src/sgml/ref/copy.sgml
--- b/doc/src/sgml/ref/copy.sgml
*************** COPY { <replaceable class="parameter">ta
*** 197,203 ****
        Selects the data format to be read or written:
        <literal>text</>,
        <literal>csv</> (Comma Separated Values),
!       or <literal>binary</>.
        The default is <literal>text</>.
       </para>
      </listitem>
--- 197,203 ----
        Selects the data format to be read or written:
        <literal>text</>,
        <literal>csv</> (Comma Separated Values),
!       <literal>binary</> or <literal>raw</literal>.
        The default is <literal>text</>.
       </para>
      </listitem>
*************** OIDs to be shown as null if that ever pr
*** 888,893 ****
--- 888,925 ----
      </para>
     </refsect3>
    </refsect2>
+ 
+   <refsect2>
+      <title>Raw Format</title>
+ 
+    <para>
+     The <literal>raw</literal> format option causes all data to be
+     stored/read as binary format rather than as text. It shares format
+     for data with <literal>binary</literal> format. This format doesn't
+     use any metadata - only row data in network byte order are exported
+     or imported.
+    </para>
+ 
+    <para>
+     Because this format doesn't support any delimiter, only one value
+     can be exported or imported. NULL values are not allowed.
+    </para>
+    <para>
+     The <literal>raw</literal> format can be used for export or import
+     bytea values.
+ <programlisting>
+ COPY images(data) FROM '/usr1/proj/img/01.jpg' (FORMAT raw);
+ </programlisting>
+     It can be used successfully for export XML in different encoding
+     or import valid XML document with any supported encoding:
+ <screen><![CDATA[
+ SET client_encoding TO latin2;
+ 
+ COPY (SELECT xmlelement(NAME data, 'Hello')) TO stdout (FORMAT raw);
+ <?xml version="1.0" encoding="LATIN2"?><data>Hello</data>
+ ]]></screen>
+    </para>
+   </refsect2>
   </refsect1>
  
   <refsect1>
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
new file mode 100644
index 3201476..1de36b6
*** a/src/backend/commands/copy.c
--- b/src/backend/commands/copy.c
*************** typedef enum EolType
*** 89,94 ****
--- 89,99 ----
   * it's faster to make useless comparisons to trailing bytes than it is to
   * invoke pg_encoding_mblen() to skip over them. encoding_embeds_ascii is TRUE
   * when we have to do it the hard way.
+  *
+  * COPY supports three modes: text, binary, raw_text and raw_binary. The text
+  * format is plain text multiline format with specified delimiter. The binary
+  * format holds metadata (numbers, sizes) and data. The raw format holds data
+  * only and only one non NULL value can be processed.
   */
  typedef struct CopyStateData
  {
*************** typedef struct CopyStateData
*** 110,115 ****
--- 115,121 ----
  	char	   *filename;		/* filename, or NULL for STDIN/STDOUT */
  	bool		is_program;		/* is 'filename' a program to popen? */
  	bool		binary;			/* binary format? */
+ 	bool		raw;			/* required raw binary? */
  	bool		oids;			/* include OIDs? */
  	bool		freeze;			/* freeze rows on loading? */
  	bool		csv_mode;		/* Comma Separated Value format? */
*************** typedef struct CopyStateData
*** 199,204 ****
--- 205,213 ----
  	char	   *raw_buf;
  	int			raw_buf_index;	/* next byte to process */
  	int			raw_buf_len;	/* total # of bytes stored */
+ 
+ 	/* field for RAW mode */
+ 	bool		row_processed;		/* true, when first row was processed */
  } CopyStateData;
  
  /* DestReceiver for COPY (query) TO */
*************** SendCopyBegin(CopyState cstate)
*** 342,353 ****
  		/* new way */
  		StringInfoData buf;
  		int			natts = list_length(cstate->attnumlist);
! 		int16		format = (cstate->binary ? 1 : 0);
  		int			i;
  
  		pq_beginmessage(&buf, 'H');
! 		pq_sendbyte(&buf, format);		/* overall format */
  		pq_sendint(&buf, natts, 2);
  		for (i = 0; i < natts; i++)
  			pq_sendint(&buf, format, 2);		/* per-column formats */
  		pq_endmessage(&buf);
--- 351,368 ----
  		/* new way */
  		StringInfoData buf;
  		int			natts = list_length(cstate->attnumlist);
! 		int16		format;
  		int			i;
  
  		pq_beginmessage(&buf, 'H');
! 		pq_sendbyte(&buf, cstate->binary ? 1 : 0);		/* overall format */
  		pq_sendint(&buf, natts, 2);
+ 
+ 		if (!cstate->raw)
+ 			format = cstate->binary ? 1 : 0;
+ 		else
+ 			format = cstate->binary ? 3 : 2;
+ 
  		for (i = 0; i < natts; i++)
  			pq_sendint(&buf, format, 2);		/* per-column formats */
  		pq_endmessage(&buf);
*************** SendCopyBegin(CopyState cstate)
*** 356,365 ****
  	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
  	{
  		/* old way */
! 		if (cstate->binary)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 			errmsg("COPY BINARY is not supported to stdout or from stdin")));
  		pq_putemptymessage('H');
  		/* grottiness needed for old COPY OUT protocol */
  		pq_startcopyout();
--- 371,380 ----
  	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
  	{
  		/* old way */
! 		if (cstate->binary || cstate->raw)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 			errmsg("COPY BINARY or COPY RAW is not supported to stdout or from stdin")));
  		pq_putemptymessage('H');
  		/* grottiness needed for old COPY OUT protocol */
  		pq_startcopyout();
*************** SendCopyBegin(CopyState cstate)
*** 368,377 ****
  	else
  	{
  		/* very old way */
! 		if (cstate->binary)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 			errmsg("COPY BINARY is not supported to stdout or from stdin")));
  		pq_putemptymessage('B');
  		/* grottiness needed for old COPY OUT protocol */
  		pq_startcopyout();
--- 383,392 ----
  	else
  	{
  		/* very old way */
! 		if (cstate->binary || cstate->raw)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 			errmsg("COPY BINARY or COPY RAW is not supported to stdout or from stdin")));
  		pq_putemptymessage('B');
  		/* grottiness needed for old COPY OUT protocol */
  		pq_startcopyout();
*************** ReceiveCopyBegin(CopyState cstate)
*** 387,398 ****
  		/* new way */
  		StringInfoData buf;
  		int			natts = list_length(cstate->attnumlist);
! 		int16		format = (cstate->binary ? 1 : 0);
  		int			i;
  
  		pq_beginmessage(&buf, 'G');
! 		pq_sendbyte(&buf, format);		/* overall format */
  		pq_sendint(&buf, natts, 2);
  		for (i = 0; i < natts; i++)
  			pq_sendint(&buf, format, 2);		/* per-column formats */
  		pq_endmessage(&buf);
--- 402,419 ----
  		/* new way */
  		StringInfoData buf;
  		int			natts = list_length(cstate->attnumlist);
! 		int16		format;
  		int			i;
  
  		pq_beginmessage(&buf, 'G');
! 		pq_sendbyte(&buf, cstate->binary ? 1 : 0);		/* overall format */
  		pq_sendint(&buf, natts, 2);
+ 
+ 		if (!cstate->raw)
+ 			format = cstate->binary ? 1 : 0;
+ 		else
+ 			format = cstate->binary ? 3 : 2;
+ 
  		for (i = 0; i < natts; i++)
  			pq_sendint(&buf, format, 2);		/* per-column formats */
  		pq_endmessage(&buf);
*************** ReceiveCopyBegin(CopyState cstate)
*** 402,408 ****
  	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
  	{
  		/* old way */
! 		if (cstate->binary)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
--- 423,429 ----
  	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
  	{
  		/* old way */
! 		if (cstate->binary || cstate->raw)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
*************** ReceiveCopyBegin(CopyState cstate)
*** 414,420 ****
  	else
  	{
  		/* very old way */
! 		if (cstate->binary)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
--- 435,441 ----
  	else
  	{
  		/* very old way */
! 		if (cstate->binary || cstate->raw)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  			errmsg("COPY BINARY is not supported to stdout or from stdin")));
*************** CopySendEndOfRow(CopyState cstate)
*** 482,488 ****
  	switch (cstate->copy_dest)
  	{
  		case COPY_FILE:
! 			if (!cstate->binary)
  			{
  				/* Default line termination depends on platform */
  #ifndef WIN32
--- 503,509 ----
  	switch (cstate->copy_dest)
  	{
  		case COPY_FILE:
! 			if (!cstate->binary && !cstate->raw)
  			{
  				/* Default line termination depends on platform */
  #ifndef WIN32
*************** CopySendEndOfRow(CopyState cstate)
*** 527,533 ****
  			break;
  		case COPY_OLD_FE:
  			/* The FE/BE protocol uses \n as newline for all platforms */
! 			if (!cstate->binary)
  				CopySendChar(cstate, '\n');
  
  			if (pq_putbytes(fe_msgbuf->data, fe_msgbuf->len))
--- 548,554 ----
  			break;
  		case COPY_OLD_FE:
  			/* The FE/BE protocol uses \n as newline for all platforms */
! 			if (!cstate->binary && !cstate->raw)
  				CopySendChar(cstate, '\n');
  
  			if (pq_putbytes(fe_msgbuf->data, fe_msgbuf->len))
*************** CopySendEndOfRow(CopyState cstate)
*** 540,546 ****
  			break;
  		case COPY_NEW_FE:
  			/* The FE/BE protocol uses \n as newline for all platforms */
! 			if (!cstate->binary)
  				CopySendChar(cstate, '\n');
  
  			/* Dump the accumulated row as one CopyData message */
--- 561,567 ----
  			break;
  		case COPY_NEW_FE:
  			/* The FE/BE protocol uses \n as newline for all platforms */
! 			if (!cstate->binary && !cstate->raw)
  				CopySendChar(cstate, '\n');
  
  			/* Dump the accumulated row as one CopyData message */
*************** CopyGetData(CopyState cstate, void *data
*** 597,602 ****
--- 618,624 ----
  			bytesread = minread;
  			break;
  		case COPY_NEW_FE:
+ 
  			while (maxread > 0 && bytesread < minread && !cstate->fe_eof)
  			{
  				int			avail;
*************** CopyGetData(CopyState cstate, void *data
*** 619,624 ****
--- 641,647 ----
  								(errcode(ERRCODE_CONNECTION_FAILURE),
  								 errmsg("unexpected EOF on client connection with an open transaction")));
  					RESUME_CANCEL_INTERRUPTS();
+ 
  					switch (mtype)
  					{
  						case 'd':		/* CopyData */
*************** CopyLoadRawBuf(CopyState cstate)
*** 766,771 ****
--- 789,825 ----
  	return (inbytes > 0);
  }
  
+ /*
+  * CopyLoadallRawBuf load all file into raw_buf.
+  *
+  * It is used for reading content in raw mode. If original RAW_BUF_SIZE is not
+  * enough, the buffer is enlarged.
+  */
+ static void
+ CopyLoadallRawBuf(CopyState cstate)
+ {
+ 	int			nbytes = 0;
+ 	int			inbytes;
+ 	Size			raw_buf_size = RAW_BUF_SIZE;
+ 
+ 	do
+ 	{
+ 		/* hold enough space for one data packet */
+ 		if ((raw_buf_size - nbytes - 1) < 8 * 1024)
+ 		{
+ 			raw_buf_size += RAW_BUF_SIZE;
+ 			cstate->raw_buf = repalloc(cstate->raw_buf, raw_buf_size);
+ 		}
+ 
+ 		inbytes = CopyGetData(cstate, cstate->raw_buf + nbytes, 1, raw_buf_size - nbytes - 1);
+ 		nbytes += inbytes;
+ 	}
+ 	while (inbytes > 0);
+ 
+ 	cstate->raw_buf[nbytes] = '\0';
+ 	cstate->raw_buf_index = 0;
+ 	cstate->raw_buf_len = nbytes;
+ }
  
  /*
   *	 DoCopy executes the SQL COPY statement
*************** ProcessCopyOptions(CopyState cstate,
*** 1013,1018 ****
--- 1067,1079 ----
  				cstate->csv_mode = true;
  			else if (strcmp(fmt, "binary") == 0)
  				cstate->binary = true;
+ 			else if (strcmp(fmt, "raw_text") == 0)
+ 				cstate->raw = true;
+ 			else if (strcmp(fmt, "raw_binary") == 0)
+ 			{
+ 				cstate->binary = true;
+ 				cstate->raw = true;
+ 			}
  			else
  				ereport(ERROR,
  						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
*************** ProcessCopyOptions(CopyState cstate,
*** 1162,1176 ****
  	 * Check for incompatible options (must do these two before inserting
  	 * defaults)
  	 */
! 	if (cstate->binary && cstate->delim)
  		ereport(ERROR,
  				(errcode(ERRCODE_SYNTAX_ERROR),
! 				 errmsg("cannot specify DELIMITER in BINARY mode")));
  
! 	if (cstate->binary && cstate->null_print)
  		ereport(ERROR,
  				(errcode(ERRCODE_SYNTAX_ERROR),
! 				 errmsg("cannot specify NULL in BINARY mode")));
  
  	/* Set defaults for omitted options */
  	if (!cstate->delim)
--- 1223,1242 ----
  	 * Check for incompatible options (must do these two before inserting
  	 * defaults)
  	 */
! 	if ((cstate->binary || cstate->raw) && cstate->delim)
  		ereport(ERROR,
  				(errcode(ERRCODE_SYNTAX_ERROR),
! 				 errmsg("cannot specify DELIMITER in BINARY or RAW mode")));
  
! 	if ((cstate->binary || cstate->raw) && cstate->null_print)
  		ereport(ERROR,
  				(errcode(ERRCODE_SYNTAX_ERROR),
! 				 errmsg("cannot specify NULL in BINARY or RAW mode")));
! 
! 	if (cstate->raw && cstate->oids)
! 		ereport(ERROR,
! 				(errcode(ERRCODE_SYNTAX_ERROR),
! 				 errmsg("cannot specify OIDS in RAW mode")));
  
  	/* Set defaults for omitted options */
  	if (!cstate->delim)
*************** BeginCopy(bool is_from,
*** 1608,1613 ****
--- 1674,1693 ----
  		}
  	}
  
+ 	/*
+ 	 * Initializaze the field "row_processed" for one row output in RAW mode,
+ 	 * and ensure only one output column.
+ 	 */
+ 	if (cstate->raw)
+ 	{
+ 		cstate->row_processed = false;
+ 
+ 		if (num_phys_attrs > 1)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 					 errmsg("only single column result is allowed in RAW mode")));
+ 	}
+ 
  	/* Use client encoding when ENCODING option is not specified. */
  	if (cstate->file_encoding < 0)
  		cstate->file_encoding = pg_get_client_encoding();
*************** CopyTo(CopyState cstate)
*** 1899,1905 ****
  											   ALLOCSET_DEFAULT_INITSIZE,
  											   ALLOCSET_DEFAULT_MAXSIZE);
  
! 	if (cstate->binary)
  	{
  		/* Generate header for a binary copy */
  		int32		tmp;
--- 1979,1985 ----
  											   ALLOCSET_DEFAULT_INITSIZE,
  											   ALLOCSET_DEFAULT_MAXSIZE);
  
! 	if (!cstate->raw && cstate->binary)
  	{
  		/* Generate header for a binary copy */
  		int32		tmp;
*************** CopyTo(CopyState cstate)
*** 1927,1933 ****
  													  cstate->file_encoding);
  
  		/* if a header has been requested send the line */
! 		if (cstate->header_line)
  		{
  			bool		hdr_delim = false;
  
--- 2007,2013 ----
  													  cstate->file_encoding);
  
  		/* if a header has been requested send the line */
! 		if (!cstate->raw && cstate->header_line)
  		{
  			bool		hdr_delim = false;
  
*************** CopyTo(CopyState cstate)
*** 1983,1993 ****
  	else
  	{
  		/* run the plan --- the dest receiver will send tuples */
! 		ExecutorRun(cstate->queryDesc, ForwardScanDirection, 0L);
  		processed = ((DR_copy *) cstate->queryDesc->dest)->processed;
  	}
  
! 	if (cstate->binary)
  	{
  		/* Generate trailer for a binary copy */
  		CopySendInt16(cstate, -1);
--- 2063,2073 ----
  	else
  	{
  		/* run the plan --- the dest receiver will send tuples */
! 		ExecutorRun(cstate->queryDesc, ForwardScanDirection, cstate->raw ? 2L : 0L);
  		processed = ((DR_copy *) cstate->queryDesc->dest)->processed;
  	}
  
! 	if (!cstate->raw && cstate->binary)
  	{
  		/* Generate trailer for a binary copy */
  		CopySendInt16(cstate, -1);
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 2015,2021 ****
  	MemoryContextReset(cstate->rowcontext);
  	oldcontext = MemoryContextSwitchTo(cstate->rowcontext);
  
! 	if (cstate->binary)
  	{
  		/* Binary per-tuple header */
  		CopySendInt16(cstate, list_length(cstate->attnumlist));
--- 2095,2109 ----
  	MemoryContextReset(cstate->rowcontext);
  	oldcontext = MemoryContextSwitchTo(cstate->rowcontext);
  
! 	if (cstate->raw)
! 	{
! 		if (cstate->row_processed)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_TOO_MANY_ROWS),
! 					 errmsg("only single row result is allowed in RAW mode")));
! 		cstate->row_processed = true;
! 	}
! 	else if (cstate->binary)
  	{
  		/* Binary per-tuple header */
  		CopySendInt16(cstate, list_length(cstate->attnumlist));
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 2046,2052 ****
  		Datum		value = values[attnum - 1];
  		bool		isnull = nulls[attnum - 1];
  
! 		if (!cstate->binary)
  		{
  			if (need_delim)
  				CopySendChar(cstate, cstate->delim[0]);
--- 2134,2140 ----
  		Datum		value = values[attnum - 1];
  		bool		isnull = nulls[attnum - 1];
  
! 		if (!(cstate->binary || cstate->raw))
  		{
  			if (need_delim)
  				CopySendChar(cstate, cstate->delim[0]);
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 2055,2068 ****
  
  		if (isnull)
  		{
! 			if (!cstate->binary)
  				CopySendString(cstate, cstate->null_print_client);
  			else
  				CopySendInt32(cstate, -1);
  		}
  		else
  		{
! 			if (!cstate->binary)
  			{
  				string = OutputFunctionCall(&out_functions[attnum - 1],
  											value);
--- 2143,2174 ----
  
  		if (isnull)
  		{
! 			if (cstate->raw)
! 					ereport(ERROR,
! 						(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
! 						  errmsg("cannot to copy NULL value in RAW mode.")));
! 			else if (!cstate->binary)
  				CopySendString(cstate, cstate->null_print_client);
  			else
  				CopySendInt32(cstate, -1);
  		}
  		else
  		{
! 			if (cstate->binary)
! 			{
! 				bytea	   *outputbytes;
! 
! 				outputbytes = SendFunctionCall(&out_functions[attnum - 1],
! 											   value);
! 
! 				/* send the size only in binary mode */
! 				if (!cstate->raw)
! 					CopySendInt32(cstate, VARSIZE(outputbytes) - VARHDRSZ);
! 
! 				CopySendData(cstate, VARDATA(outputbytes),
! 							 VARSIZE(outputbytes) - VARHDRSZ);
! 			}
! 			else
  			{
  				string = OutputFunctionCall(&out_functions[attnum - 1],
  											value);
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 2073,2088 ****
  				else
  					CopyAttributeOutText(cstate, string);
  			}
- 			else
- 			{
- 				bytea	   *outputbytes;
- 
- 				outputbytes = SendFunctionCall(&out_functions[attnum - 1],
- 											   value);
- 				CopySendInt32(cstate, VARSIZE(outputbytes) - VARHDRSZ);
- 				CopySendData(cstate, VARDATA(outputbytes),
- 							 VARSIZE(outputbytes) - VARHDRSZ);
- 			}
  		}
  	}
  
--- 2179,2184 ----
*************** BeginCopyFrom(Relation rel,
*** 2811,2859 ****
  		}
  	}
  
! 	if (!cstate->binary)
! 	{
! 		/* must rely on user to tell us... */
! 		cstate->file_has_oids = cstate->oids;
! 	}
! 	else
  	{
! 		/* Read and verify binary header */
! 		char		readSig[11];
! 		int32		tmp;
! 
! 		/* Signature */
! 		if (CopyGetData(cstate, readSig, 11, 11) != 11 ||
! 			memcmp(readSig, BinarySignature, 11) != 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("COPY file signature not recognized")));
! 		/* Flags field */
! 		if (!CopyGetInt32(cstate, &tmp))
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("invalid COPY file header (missing flags)")));
! 		cstate->file_has_oids = (tmp & (1 << 16)) != 0;
! 		tmp &= ~(1 << 16);
! 		if ((tmp >> 16) != 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 				 errmsg("unrecognized critical flags in COPY file header")));
! 		/* Header extension length */
! 		if (!CopyGetInt32(cstate, &tmp) ||
! 			tmp < 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("invalid COPY file header (missing length)")));
! 		/* Skip extension header, if present */
! 		while (tmp-- > 0)
  		{
! 			if (CopyGetData(cstate, readSig, 1, 1) != 1)
  				ereport(ERROR,
  						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("invalid COPY file header (wrong length)")));
  		}
  	}
  
  	if (cstate->file_has_oids && cstate->binary)
  	{
--- 2907,2956 ----
  		}
  	}
  
! 	if (cstate->binary)
  	{
! 		if (!cstate->raw)
  		{
! 			/* Read and verify binary header */
! 			char		readSig[11];
! 			int32		tmp;
! 
! 			/* Signature */
! 			if (CopyGetData(cstate, readSig, 11, 11) != 11 ||
! 				memcmp(readSig, BinarySignature, 11) != 0)
  				ereport(ERROR,
  						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("COPY file signature not recognized")));
! 			/* Flags field */
! 			if (!CopyGetInt32(cstate, &tmp))
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("invalid COPY file header (missing flags)")));
! 			cstate->file_has_oids = (tmp & (1 << 16)) != 0;
! 			tmp &= ~(1 << 16);
! 			if ((tmp >> 16) != 0)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("unrecognized critical flags in COPY file header")));
! 			/* Header extension length */
! 			if (!CopyGetInt32(cstate, &tmp) ||
! 				tmp < 0)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("invalid COPY file header (missing length)")));
! 			/* Skip extension header, if present */
! 			while (tmp-- > 0)
! 			{
! 				if (CopyGetData(cstate, readSig, 1, 1) != 1)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							 errmsg("invalid COPY file header (wrong length)")));
! 			}
  		}
  	}
+ 	else
+ 		cstate->file_has_oids = cstate->oids;
+ 
  
  	if (cstate->file_has_oids && cstate->binary)
  	{
*************** NextCopyFromRawFields(CopyState cstate,
*** 2918,2928 ****
  	if (done && cstate->line_buf.len == 0)
  		return false;
  
! 	/* Parse the line into de-escaped field values */
! 	if (cstate->csv_mode)
! 		fldct = CopyReadAttributesCSV(cstate);
  	else
! 		fldct = CopyReadAttributesText(cstate);
  
  	*fields = cstate->raw_fields;
  	*nfields = fldct;
--- 3015,3051 ----
  	if (done && cstate->line_buf.len == 0)
  		return false;
  
! 	/* try to read all content in raw mode */
! 	if (cstate->raw)
! 	{
! 		StringInfoData	lines;
! 
! 		initStringInfo(&lines);
! 
! 		do
! 		{
! 			if (lines.len > 0)
! 				appendStringInfoChar(&lines, '\n');
! 
! 			appendBinaryStringInfo(&lines, cstate->line_buf.data, cstate->line_buf.len);
! 
! 			cstate->cur_lineno++;
! 			done = CopyReadLine(cstate);
! 		} while (!(done && cstate->line_buf.len == 0));
! 
! 		appendStringInfoChar(&lines, '\0');
! 
! 		cstate->raw_fields[0] = &lines.data;
! 		fldct = 1;
! 	}
  	else
! 	{
! 		/* Parse the line into de-escaped field values */
! 		if (cstate->csv_mode)
! 			fldct = CopyReadAttributesCSV(cstate);
! 		else
! 			fldct = CopyReadAttributesText(cstate);
! 	}
  
  	*fields = cstate->raw_fields;
  	*nfields = fldct;
*************** NextCopyFrom(CopyState cstate, ExprConte
*** 2968,2975 ****
  	MemSet(values, 0, num_phys_attrs * sizeof(Datum));
  	MemSet(nulls, true, num_phys_attrs * sizeof(bool));
  
! 	if (!cstate->binary)
  	{
  		char	  **field_strings;
  		ListCell   *cur;
  		int			fldct;
--- 3091,3210 ----
  	MemSet(values, 0, num_phys_attrs * sizeof(Datum));
  	MemSet(nulls, true, num_phys_attrs * sizeof(bool));
  
! 	if (cstate->binary && !cstate->raw)
! 	{
! 		int16		fld_count;
! 		ListCell   *cur;
! 
! 		cstate->cur_lineno++;
! 
! 		if (!CopyGetInt16(cstate, &fld_count))
! 		{
! 			/* EOF detected (end of file, or protocol-level EOF) */
! 			return false;
! 		}
! 
! 		if (fld_count == -1)
! 		{
! 			/*
! 			 * Received EOF marker.  In a V3-protocol copy, wait for the
! 			 * protocol-level EOF, and complain if it doesn't come
! 			 * immediately.  This ensures that we correctly handle CopyFail,
! 			 * if client chooses to send that now.
! 			 *
! 			 * Note that we MUST NOT try to read more data in an old-protocol
! 			 * copy, since there is no protocol-level EOF marker then.  We
! 			 * could go either way for copy from file, but choose to throw
! 			 * error if there's data after the EOF marker, for consistency
! 			 * with the new-protocol case.
! 			 */
! 			char		dummy;
! 
! 			if (cstate->copy_dest != COPY_OLD_FE &&
! 				CopyGetData(cstate, &dummy, 1, 1) > 0)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("received copy data after EOF marker")));
! 			return false;
! 		}
! 
! 		if (fld_count != attr_count)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("row field count is %d, expected %d",
! 							(int) fld_count, attr_count)));
! 
! 		if (file_has_oids)
! 		{
! 			Oid			loaded_oid;
! 
! 			cstate->cur_attname = "oid";
! 			loaded_oid =
! 				DatumGetObjectId(CopyReadBinaryAttribute(cstate,
! 														 0,
! 													&cstate->oid_in_function,
! 													  cstate->oid_typioparam,
! 														 -1,
! 														 &isnull));
! 			if (isnull || loaded_oid == InvalidOid)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("invalid OID in COPY data")));
! 			cstate->cur_attname = NULL;
! 			if (cstate->oids && tupleOid != NULL)
! 				*tupleOid = loaded_oid;
! 		}
! 
! 		i = 0;
! 		foreach(cur, cstate->attnumlist)
! 		{
! 			int			attnum = lfirst_int(cur);
! 			int			m = attnum - 1;
! 
! 			cstate->cur_attname = NameStr(attr[m]->attname);
! 			i++;
! 			values[m] = CopyReadBinaryAttribute(cstate,
! 												i,
! 												&in_functions[m],
! 												typioparams[m],
! 												attr[m]->atttypmod,
! 												&nulls[m]);
! 			cstate->cur_attname = NULL;
! 		}
! 	}
! 	else if (cstate->binary && cstate->raw)
! 	{
! 		if (cstate->row_processed)
! 			return false;
! 
! 		CopyLoadallRawBuf(cstate);
! 		cstate->cur_attname = NameStr(attr[0]->attname);
! 
! 		if (cstate->attribute_buf.data != NULL)
! 			pfree(cstate->attribute_buf.data);
! 
! 		cstate->attribute_buf.data = cstate->raw_buf;
! 		cstate->attribute_buf.len = cstate->raw_buf_len;
! 		cstate->attribute_buf.cursor = 0;
! 
! 		cstate->raw_buf = NULL;
! 
! 		/* Call the column type's binary input converter */
! 		values[0] = ReceiveFunctionCall(&in_functions[0], &cstate->attribute_buf,
! 								 typioparams[0], attr[0]->atttypmod);
! 		nulls[0] = false;
! 
! 		/* Trouble if it didn't eat the whole buffer */
! 		if (cstate->attribute_buf.cursor != cstate->attribute_buf.len)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
! 					 errmsg("incorrect binary data format")));
! 
! 		cstate->row_processed = true;
! 	}
! 	else
  	{
+ 		/* text */
  		char	  **field_strings;
  		ListCell   *cur;
  		int			fldct;
*************** NextCopyFrom(CopyState cstate, ExprConte
*** 3074,3161 ****
  
  		Assert(fieldno == nfields);
  	}
- 	else
- 	{
- 		/* binary */
- 		int16		fld_count;
- 		ListCell   *cur;
- 
- 		cstate->cur_lineno++;
- 
- 		if (!CopyGetInt16(cstate, &fld_count))
- 		{
- 			/* EOF detected (end of file, or protocol-level EOF) */
- 			return false;
- 		}
- 
- 		if (fld_count == -1)
- 		{
- 			/*
- 			 * Received EOF marker.  In a V3-protocol copy, wait for the
- 			 * protocol-level EOF, and complain if it doesn't come
- 			 * immediately.  This ensures that we correctly handle CopyFail,
- 			 * if client chooses to send that now.
- 			 *
- 			 * Note that we MUST NOT try to read more data in an old-protocol
- 			 * copy, since there is no protocol-level EOF marker then.  We
- 			 * could go either way for copy from file, but choose to throw
- 			 * error if there's data after the EOF marker, for consistency
- 			 * with the new-protocol case.
- 			 */
- 			char		dummy;
- 
- 			if (cstate->copy_dest != COPY_OLD_FE &&
- 				CopyGetData(cstate, &dummy, 1, 1) > 0)
- 				ereport(ERROR,
- 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
- 						 errmsg("received copy data after EOF marker")));
- 			return false;
- 		}
- 
- 		if (fld_count != attr_count)
- 			ereport(ERROR,
- 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
- 					 errmsg("row field count is %d, expected %d",
- 							(int) fld_count, attr_count)));
- 
- 		if (file_has_oids)
- 		{
- 			Oid			loaded_oid;
- 
- 			cstate->cur_attname = "oid";
- 			loaded_oid =
- 				DatumGetObjectId(CopyReadBinaryAttribute(cstate,
- 														 0,
- 													&cstate->oid_in_function,
- 													  cstate->oid_typioparam,
- 														 -1,
- 														 &isnull));
- 			if (isnull || loaded_oid == InvalidOid)
- 				ereport(ERROR,
- 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
- 						 errmsg("invalid OID in COPY data")));
- 			cstate->cur_attname = NULL;
- 			if (cstate->oids && tupleOid != NULL)
- 				*tupleOid = loaded_oid;
- 		}
- 
- 		i = 0;
- 		foreach(cur, cstate->attnumlist)
- 		{
- 			int			attnum = lfirst_int(cur);
- 			int			m = attnum - 1;
- 
- 			cstate->cur_attname = NameStr(attr[m]->attname);
- 			i++;
- 			values[m] = CopyReadBinaryAttribute(cstate,
- 												i,
- 												&in_functions[m],
- 												typioparams[m],
- 												attr[m]->atttypmod,
- 												&nulls[m]);
- 			cstate->cur_attname = NULL;
- 		}
- 	}
  
  	/*
  	 * Now compute and insert any defaults available for the columns not
--- 3309,3314 ----
*************** CopyAttributeOutText(CopyState cstate, c
*** 4143,4148 ****
--- 4296,4312 ----
  		ptr = string;
  
  	/*
+ 	 * Do not any escaping when raw mode is used. In this mode only one field
+ 	 * is passed - so escaping is useless. We would to work with raw data, i.e.
+ 	 * no escaping.
+ 	 */
+ 	if (cstate->raw)
+ 	{
+ 		CopySendString(cstate, ptr);
+ 		return;
+ 	}
+ 
+ 	/*
  	 * 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
*************** CopyAttributeOutText(CopyState cstate, c
*** 4156,4162 ****
  	 * 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)
  	{
  		start = ptr;
  		while ((c = *ptr) != '\0')
--- 4320,4326 ----
  	 * it's worth making two copies of it to get the IS_HIGHBIT_SET() test out
  	 * of the normal safe-encoding path.
  	 */
! 	else if (cstate->encoding_embeds_ascii)
  	{
  		start = ptr;
  		while ((c = *ptr) != '\0')
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
new file mode 100644
index 892058e..777a375
*** a/src/bin/psql/common.c
--- b/src/bin/psql/common.c
*************** ProcessResult(PGresult **results)
*** 871,876 ****
--- 871,877 ----
  			{
  				if (!copystream)
  					copystream = pset.cur_cmd_source;
+ 
  				success = handleCopyIn(pset.db,
  									   copystream,
  									   PQbinaryTuples(*results),
diff --git a/src/interfaces/libpq/Makefile b/src/interfaces/libpq/Makefile
new file mode 100644
index 1b292d2..83b30b0
*** a/src/interfaces/libpq/Makefile
--- b/src/interfaces/libpq/Makefile
*************** include $(top_builddir)/src/Makefile.glo
*** 17,23 ****
  # shared library parameters
  NAME= pq
  SO_MAJOR_VERSION= 5
! SO_MINOR_VERSION= 9
  
  override CPPFLAGS :=  -DFRONTEND -DUNSAFE_STAT_OK -I$(srcdir) $(CPPFLAGS) -I$(top_builddir)/src/port -I$(top_srcdir)/src/port
  ifneq ($(PORTNAME), win32)
--- 17,23 ----
  # shared library parameters
  NAME= pq
  SO_MAJOR_VERSION= 5
! SO_MINOR_VERSION= 10
  
  override CPPFLAGS :=  -DFRONTEND -DUNSAFE_STAT_OK -I$(srcdir) $(CPPFLAGS) -I$(top_builddir)/src/port -I$(top_srcdir)/src/port
  ifneq ($(PORTNAME), win32)
diff --git a/src/interfaces/libpq/fe-exec.c b/src/interfaces/libpq/fe-exec.c
new file mode 100644
index 41937c0..096ed6b
*** a/src/interfaces/libpq/fe-exec.c
--- b/src/interfaces/libpq/fe-exec.c
*************** PQmakeEmptyPGresult(PGconn *conn, ExecSt
*** 155,160 ****
--- 155,161 ----
  	result->resultStatus = status;
  	result->cmdStatus[0] = '\0';
  	result->binary = 0;
+ 	result->raw = 0;
  	result->events = NULL;
  	result->nEvents = 0;
  	result->errMsg = NULL;
*************** PQsetResultAttrs(PGresult *res, int numA
*** 245,250 ****
--- 246,252 ----
  
  	/* deep-copy the attribute names, and determine format */
  	res->binary = 1;
+ 	res->raw = 0;
  	for (i = 0; i < res->numAttributes; i++)
  	{
  		if (res->attDescs[i].name)
*************** PQsetResultAttrs(PGresult *res, int numA
*** 255,262 ****
  		if (!res->attDescs[i].name)
  			return FALSE;
  
! 		if (res->attDescs[i].format == 0)
  			res->binary = 0;
  	}
  
  	return TRUE;
--- 257,266 ----
  		if (!res->attDescs[i].name)
  			return FALSE;
  
! 		if (res->attDescs[i].format == 0 || res->attDescs[i].format == 2)
  			res->binary = 0;
+ 		if (res->attDescs[i].format == 2 || res->attDescs[i].format == 3)
+ 			res->raw = 1;
  	}
  
  	return TRUE;
*************** PQcopyResult(const PGresult *src, int fl
*** 372,377 ****
--- 376,382 ----
  	return dest;
  }
  
+ 
  /*
   * Copy an array of PGEvents (with no extra space for more).
   * Does not duplicate the event instance data, sets this to NULL.
*************** PQbinaryTuples(const PGresult *res)
*** 2634,2639 ****
--- 2639,2645 ----
  {
  	if (!res)
  		return 0;
+ 
  	return res->binary;
  }
  
*************** PQfmod(const PGresult *res, int field_nu
*** 2884,2889 ****
--- 2890,2910 ----
  		return 0;
  }
  
+ /*
+  * PQcopyFormat
+  *
+  * Returns a info about copy mode:
+  * -1 signalize a error, 0 = text mode, 1 = binary mode, 2 = raw mode
+  */
+ int
+ PQcopyFormat(const PGresult *res)
+ {
+ 	if (res->raw)
+ 		return 2;
+ 	else
+ 		return res->binary;
+ }
+ 
  char *
  PQcmdStatus(PGresult *res)
  {
diff --git a/src/interfaces/libpq/fe-protocol3.c b/src/interfaces/libpq/fe-protocol3.c
new file mode 100644
index 43898a4..3934b1d
*** a/src/interfaces/libpq/fe-protocol3.c
--- b/src/interfaces/libpq/fe-protocol3.c
*************** getCopyStart(PGconn *conn, ExecStatusTyp
*** 1397,1402 ****
--- 1397,1403 ----
  
  	if (pqGetc(&conn->copy_is_binary, conn))
  		goto failure;
+ 
  	result->binary = conn->copy_is_binary;
  	/* the next two bytes are the number of fields	*/
  	if (pqGetInt(&(result->numAttributes), 2, conn))
*************** getCopyStart(PGconn *conn, ExecStatusTyp
*** 1426,1431 ****
--- 1427,1436 ----
  		 */
  		format = (int) ((int16) format);
  		result->attDescs[i].format = format;
+ 
+ 		/* when any fields uses raw format, then COPY RAW was used */
+ 		if (format == 2 || format == 3)
+ 			result->raw = true;
  	}
  
  	/* Success! */
diff --git a/src/interfaces/libpq/libpq-fe.h b/src/interfaces/libpq/libpq-fe.h
new file mode 100644
index 6bf34b3..9f7903a
*** a/src/interfaces/libpq/libpq-fe.h
--- b/src/interfaces/libpq/libpq-fe.h
*************** extern int	PQfformat(const PGresult *res
*** 475,480 ****
--- 475,481 ----
  extern Oid	PQftype(const PGresult *res, int field_num);
  extern int	PQfsize(const PGresult *res, int field_num);
  extern int	PQfmod(const PGresult *res, int field_num);
+ extern int	PQcopyFormat(const PGresult *res);
  extern char *PQcmdStatus(PGresult *res);
  extern char *PQoidStatus(const PGresult *res);	/* old and ugly */
  extern Oid	PQoidValue(const PGresult *res);	/* new and improved */
diff --git a/src/interfaces/libpq/libpq-int.h b/src/interfaces/libpq/libpq-int.h
new file mode 100644
index 6c9bbf7..6b4d923
*** a/src/interfaces/libpq/libpq-int.h
--- b/src/interfaces/libpq/libpq-int.h
*************** struct pg_result
*** 180,185 ****
--- 180,186 ----
  	char		cmdStatus[CMDSTATUS_LEN];		/* cmd status from the query */
  	int			binary;			/* binary tuple values if binary == 1,
  								 * otherwise text */
+ 	int			raw;			/* only values */
  
  	/*
  	 * These fields are copied from the originating PGconn, so that operations
diff --git a/src/test/regress/expected/copy2.out b/src/test/regress/expected/copy2.out
new file mode 100644
index 5f6260a..e31c4f2
*** a/src/test/regress/expected/copy2.out
--- b/src/test/regress/expected/copy2.out
*************** DROP FUNCTION truncate_in_subxact();
*** 466,468 ****
--- 466,481 ----
  DROP TABLE x, y;
  DROP FUNCTION fn_x_before();
  DROP FUNCTION fn_x_after();
+ CREATE TABLE x(a bytea);
+ INSERT INTO x VALUES('\x41484f4a0a');
+ INSERT INTO x VALUES('\x41484f4a0a');
+ -- should to fail
+ COPY (SELECT a,a FROM x LIMIT 1) TO STDOUT (FORMAT raw_binary);
+ ERROR:  only single column result is allowed in RAW mode
+ COPY (SELECT a FROM x) TO STDOUT (FORMAT raw_binary);
+ AHOJ
+ ERROR:  only single row result is allowed in RAW mode
+ -- should be ok
+ COPY (SELECT a FROM x LIMIT 1) TO STDOUT (FORMAT raw_binary);
+ AHOJ
+ DROP TABLE x;
diff --git a/src/test/regress/input/copy.source b/src/test/regress/input/copy.source
new file mode 100644
index cb13606..e25f996
*** a/src/test/regress/input/copy.source
--- b/src/test/regress/input/copy.source
*************** this is just a line full of junk that wo
*** 133,135 ****
--- 133,195 ----
  \.
  
  copy copytest3 to stdout csv header;
+ 
+ -- copy raw
+ CREATE TABLE x(a bytea);
+ INSERT INTO x VALUES('\x41484f4a0a');
+ SELECT length(a) FROM x;
+ 
+ INSERT INTO x VALUES('\x41484f4a0a');
+ 
+ -- should to fail
+ COPY (SELECT a,a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ COPY (SELECT a FROM x) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ 
+ -- should be ok
+ COPY (SELECT a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ TRUNCATE x;
+ COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ SELECT length(a) FROM x;
+ COPY x TO stdout (FORMAT raw_binary);
+ 
+ TRUNCATE x;
+ 
+ \COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw_binary)
+ SELECT length(a) FROM x;
+ COPY x TO stdout (FORMAT raw_binary);
+ 
+ \COPY x TO '@abs_builddir@/results/raw2.data' (FORMAT raw_binary)
+ TRUNCATE x;
+ 
+ \COPY x FROM '@abs_builddir@/results/raw2.data' (FORMAT raw_binary)
+ SELECT length(a) FROM x;
+ COPY x TO stdout (FORMAT raw_binary);
+ 
+ -- test big file
+ TRUNCATE x;
+ -- use different mechanism for load to bytea
+ \lo_import @abs_builddir@/data/hash.data
+ \set lo_oid :LASTOID
+ INSERT INTO x VALUES(lo_get(:lo_oid));
+ \lo_unlink :lo_oid
+ 
+ COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary);
+ \COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary)
+ 
+ SELECT md5(a), length(a) FROM x;
+ 
+ TRUNCATE x;
+ COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary);
+ COPY x TO '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+ \COPY x TO '@abs_builddir@/results/hash3.data' (FORMAT raw_binary)
+ 
+ -- read again
+ COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+ \COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw_binary)
+ -- cross
+ COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw_binary);
+ \COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary)
+ 
+ SELECT md5(a), length(a) FROM x;
+ 
+ DROP TABLE x;
diff --git a/src/test/regress/output/copy.source b/src/test/regress/output/copy.source
new file mode 100644
index b7e372d..6c82993
*** a/src/test/regress/output/copy.source
--- b/src/test/regress/output/copy.source
*************** copy copytest3 to stdout csv header;
*** 95,97 ****
--- 95,183 ----
  c1,"col with , comma","col with "" quote"
  1,a,1
  2,b,2
+ -- copy raw
+ CREATE TABLE x(a bytea);
+ INSERT INTO x VALUES('\x41484f4a0a');
+ SELECT length(a) FROM x;
+  length 
+ --------
+       5
+ (1 row)
+ 
+ INSERT INTO x VALUES('\x41484f4a0a');
+ -- should to fail
+ COPY (SELECT a,a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ ERROR:  only single column result is allowed in RAW mode
+ COPY (SELECT a FROM x) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ ERROR:  only single row result is allowed in RAW mode
+ -- should be ok
+ COPY (SELECT a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ TRUNCATE x;
+ COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ SELECT length(a) FROM x;
+  length 
+ --------
+       5
+ (1 row)
+ 
+ COPY x TO stdout (FORMAT raw_binary);
+ AHOJ
+ TRUNCATE x;
+ \COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw_binary)
+ SELECT length(a) FROM x;
+  length 
+ --------
+       5
+ (1 row)
+ 
+ COPY x TO stdout (FORMAT raw_binary);
+ AHOJ
+ \COPY x TO '@abs_builddir@/results/raw2.data' (FORMAT raw_binary)
+ TRUNCATE x;
+ \COPY x FROM '@abs_builddir@/results/raw2.data' (FORMAT raw_binary)
+ SELECT length(a) FROM x;
+  length 
+ --------
+       5
+ (1 row)
+ 
+ COPY x TO stdout (FORMAT raw_binary);
+ AHOJ
+ -- test big file
+ TRUNCATE x;
+ -- use different mechanism for load to bytea
+ \lo_import @abs_builddir@/data/hash.data
+ \set lo_oid :LASTOID
+ INSERT INTO x VALUES(lo_get(:lo_oid));
+ \lo_unlink :lo_oid
+ COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary);
+ \COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary)
+ SELECT md5(a), length(a) FROM x;
+                md5                | length 
+ ----------------------------------+--------
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+ (3 rows)
+ 
+ TRUNCATE x;
+ COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary);
+ COPY x TO '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+ \COPY x TO '@abs_builddir@/results/hash3.data' (FORMAT raw_binary)
+ -- read again
+ COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+ \COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw_binary)
+ -- cross
+ COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw_binary);
+ \COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary)
+ SELECT md5(a), length(a) FROM x;
+                md5                | length 
+ ----------------------------------+--------
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+ (5 rows)
+ 
+ DROP TABLE x;
diff --git a/src/test/regress/sql/copy2.sql b/src/test/regress/sql/copy2.sql
new file mode 100644
index 39a9deb..7e22ee4
*** a/src/test/regress/sql/copy2.sql
--- b/src/test/regress/sql/copy2.sql
*************** DROP FUNCTION truncate_in_subxact();
*** 333,335 ****
--- 333,348 ----
  DROP TABLE x, y;
  DROP FUNCTION fn_x_before();
  DROP FUNCTION fn_x_after();
+ 
+ CREATE TABLE x(a bytea);
+ INSERT INTO x VALUES('\x41484f4a0a');
+ INSERT INTO x VALUES('\x41484f4a0a');
+ 
+ -- should to fail
+ COPY (SELECT a,a FROM x LIMIT 1) TO STDOUT (FORMAT raw_binary);
+ COPY (SELECT a FROM x) TO STDOUT (FORMAT raw_binary);
+ 
+ -- should be ok
+ COPY (SELECT a FROM x LIMIT 1) TO STDOUT (FORMAT raw_binary);
+ 
+ DROP TABLE x;

diff --git a/doc/src/sgml/libpq.sgml b/doc/src/sgml/libpq.sgml
new file mode 100644
index 3829a14..7b9ed73
*** a/doc/src/sgml/libpq.sgml
--- b/doc/src/sgml/libpq.sgml
*************** int PQfformat(const PGresult *res,
*** 3226,3233 ****
  
        <para>
         Format code zero indicates textual data representation, while format
!        code one indicates binary representation.  (Other codes are reserved
!        for future definition.)
        </para>
       </listitem>
      </varlistentry>
--- 3226,3234 ----
  
        <para>
         Format code zero indicates textual data representation, while format
!        code one indicates binary representation. Format code two indicates
!        raw_text representation and format code three indicates raw_binary
!        representation (Other codes are reserved for future definition.)
        </para>
       </listitem>
      </varlistentry>
*************** typedef struct
*** 3557,3562 ****
--- 3558,3583 ----
     </para>
  
     <variablelist>
+     <varlistentry id="libpq-pqcopyformat">
+      <term>
+       <function>PQcopyFormat</function>
+       <indexterm>
+        <primary>PQcopyFormat</primary>
+       </indexterm>
+      </term>
+ 
+      <listitem>
+       <para>
+        Format code zero indicates textual data representation, format one
+        indicates binary representation, format two indicates raw
+        representation.
+ <synopsis>
+ int PQcopyFormat(PGresult *res);
+ </synopsis>
+       </para>
+      </listitem>
+     </varlistentry>
+ 
      <varlistentry id="libpq-pqcmdstatus">
       <term>
        <function>PQcmdStatus</function>
diff --git a/doc/src/sgml/protocol.sgml b/doc/src/sgml/protocol.sgml
new file mode 100644
index 522128e..e783b30
*** a/doc/src/sgml/protocol.sgml
--- b/doc/src/sgml/protocol.sgml
*************** CopyInResponse (B)
*** 3239,3244 ****
--- 3239,3245 ----
                  characters, etc).
                  1 indicates the overall copy format is binary (similar
                  to DataRow format).
+                 2 indicates the overall copy format is raw.
                  See <xref linkend="sql-copy">
                  for more information.
  </para>
*************** CopyInResponse (B)
*** 3262,3269 ****
  <listitem>
  <para>
                  The format codes to be used for each column.
!                 Each must presently be zero (text) or one (binary).
!                 All must be zero if the overall copy format is textual.
  </para>
  </listitem>
  </varlistentry>
--- 3263,3271 ----
  <listitem>
  <para>
                  The format codes to be used for each column.
!                 Each must be zero (text), one (binary), two (raw_text)
!                 or three (raw_binary). All must be zero if the overall
!                 copy format is textual.
  </para>
  </listitem>
  </varlistentry>
*************** CopyOutResponse (B)
*** 3313,3319 ****
                  is textual (rows separated by newlines, columns
                  separated by separator characters, etc). 1 indicates
                  the overall copy format is binary (similar to DataRow
!                 format). See <xref linkend="sql-copy"> for more information.
  </para>
  </listitem>
  </varlistentry>
--- 3315,3322 ----
                  is textual (rows separated by newlines, columns
                  separated by separator characters, etc). 1 indicates
                  the overall copy format is binary (similar to DataRow
!                 format). 2 indicates raw_text or raw_binary format.
!                 See <xref linkend="sql-copy"> for more information.
  </para>
  </listitem>
  </varlistentry>
*************** CopyOutResponse (B)
*** 3335,3342 ****
  <listitem>
  <para>
                  The format codes to be used for each column.
!                 Each must presently be zero (text) or one (binary).
!                 All must be zero if the overall copy format is textual.
  </para>
  </listitem>
  </varlistentry>
--- 3338,3346 ----
  <listitem>
  <para>
                  The format codes to be used for each column.
!                 Each must be zero (text), one (binary), two (raw_text)
!                 or three (raw_binary). All must be zero if the overall
!                 copy format is textual.
  </para>
  </listitem>
  </varlistentry>
diff --git a/doc/src/sgml/ref/copy.sgml b/doc/src/sgml/ref/copy.sgml
new file mode 100644
index 07e2f45..4e339e4
*** a/doc/src/sgml/ref/copy.sgml
--- b/doc/src/sgml/ref/copy.sgml
*************** COPY { <replaceable class="parameter">ta
*** 197,203 ****
        Selects the data format to be read or written:
        <literal>text</>,
        <literal>csv</> (Comma Separated Values),
!       or <literal>binary</>.
        The default is <literal>text</>.
       </para>
      </listitem>
--- 197,205 ----
        Selects the data format to be read or written:
        <literal>text</>,
        <literal>csv</> (Comma Separated Values),
!       <literal>binary</>,
!       <literal>raw_text</>
!       or <literal>raw_binary</>.
        The default is <literal>text</>.
       </para>
      </listitem>
*************** OIDs to be shown as null if that ever pr
*** 888,893 ****
--- 890,933 ----
      </para>
     </refsect3>
    </refsect2>
+ 
+   <refsect2>
+      <title>Raw_text/raw_binary Format</title>
+ 
+    <para>
+     The <literal>raw_text</literal> format option causes all data to be
+     stored/read as one text value. This format doesn't use any metadata
+     - only raw data are exported or imported.
+    </para>
+ 
+    <para>
+     The <literal>raw_binary</literal> format option causes all data to be
+     stored/read as binary format rather than as text. It shares format
+     for data with <literal>binary</literal> format. This format doesn't
+     use any metadata - only row data in network byte order are exported
+     or imported.
+    </para>
+ 
+    <para>
+     Because this format doesn't support any delimiter, only one value
+     can be exported or imported. NULL values are not allowed.
+    </para>
+    <para>
+     The <literal>raw_binary</literal> format can be used for export or import
+     bytea values.
+ <programlisting>
+ COPY images(data) FROM '/usr1/proj/img/01.jpg' (FORMAT raw_binary);
+ </programlisting>
+     It can be used successfully for export XML in different encoding
+     or import valid XML document with any supported encoding:
+ <screen><![CDATA[
+ SET client_encoding TO latin2;
+ 
+ COPY (SELECT xmlelement(NAME data, 'Hello')) TO stdout (FORMAT raw_binary);
+ <?xml version="1.0" encoding="LATIN2"?><data>Hello</data>
+ ]]></screen>
+    </para>
+   </refsect2>
   </refsect1>
  
   <refsect1>
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
new file mode 100644
index 3201476..7600829
*** a/src/backend/commands/copy.c
--- b/src/backend/commands/copy.c
*************** typedef struct CopyStateData
*** 110,115 ****
--- 110,116 ----
  	char	   *filename;		/* filename, or NULL for STDIN/STDOUT */
  	bool		is_program;		/* is 'filename' a program to popen? */
  	bool		binary;			/* binary format? */
+ 	bool		raw;			/* raw mode? */
  	bool		oids;			/* include OIDs? */
  	bool		freeze;			/* freeze rows on loading? */
  	bool		csv_mode;		/* Comma Separated Value format? */
*************** SendCopyBegin(CopyState cstate)
*** 342,353 ****
  		/* new way */
  		StringInfoData buf;
  		int			natts = list_length(cstate->attnumlist);
! 		int16		format = (cstate->binary ? 1 : 0);
  		int			i;
  
  		pq_beginmessage(&buf, 'H');
! 		pq_sendbyte(&buf, format);		/* overall format */
  		pq_sendint(&buf, natts, 2);
  		for (i = 0; i < natts; i++)
  			pq_sendint(&buf, format, 2);		/* per-column formats */
  		pq_endmessage(&buf);
--- 343,369 ----
  		/* new way */
  		StringInfoData buf;
  		int			natts = list_length(cstate->attnumlist);
! 		int16		format;
! 		int			mode;
  		int			i;
  
  		pq_beginmessage(&buf, 'H');
! 
! 		if (cstate->raw)
! 			mode = 2;
! 		else if (cstate->binary)
! 			mode = 1;
! 		else
! 			mode = 0;
! 
! 		pq_sendbyte(&buf, mode);		/* overall mode */
  		pq_sendint(&buf, natts, 2);
+ 
+ 		if (!cstate->raw)
+ 			format = cstate->binary ? 1 : 0;
+ 		else
+ 			format = cstate->binary ? 3 : 2;
+ 
  		for (i = 0; i < natts; i++)
  			pq_sendint(&buf, format, 2);		/* per-column formats */
  		pq_endmessage(&buf);
*************** SendCopyBegin(CopyState cstate)
*** 356,365 ****
  	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
  	{
  		/* old way */
! 		if (cstate->binary)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 			errmsg("COPY BINARY is not supported to stdout or from stdin")));
  		pq_putemptymessage('H');
  		/* grottiness needed for old COPY OUT protocol */
  		pq_startcopyout();
--- 372,381 ----
  	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
  	{
  		/* old way */
! 		if (cstate->binary || cstate->raw)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 			errmsg("COPY BINARY or COPY RAW_TEXT/RAW_BINARY is not supported to stdout or from stdin")));
  		pq_putemptymessage('H');
  		/* grottiness needed for old COPY OUT protocol */
  		pq_startcopyout();
*************** SendCopyBegin(CopyState cstate)
*** 368,377 ****
  	else
  	{
  		/* very old way */
! 		if (cstate->binary)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 			errmsg("COPY BINARY is not supported to stdout or from stdin")));
  		pq_putemptymessage('B');
  		/* grottiness needed for old COPY OUT protocol */
  		pq_startcopyout();
--- 384,393 ----
  	else
  	{
  		/* very old way */
! 		if (cstate->binary || cstate->raw)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 			errmsg("COPY BINARY or COPY RAW_TEXT/RAW_BINARY is not supported to stdout or from stdin")));
  		pq_putemptymessage('B');
  		/* grottiness needed for old COPY OUT protocol */
  		pq_startcopyout();
*************** ReceiveCopyBegin(CopyState cstate)
*** 387,398 ****
  		/* new way */
  		StringInfoData buf;
  		int			natts = list_length(cstate->attnumlist);
! 		int16		format = (cstate->binary ? 1 : 0);
  		int			i;
  
  		pq_beginmessage(&buf, 'G');
! 		pq_sendbyte(&buf, format);		/* overall format */
  		pq_sendint(&buf, natts, 2);
  		for (i = 0; i < natts; i++)
  			pq_sendint(&buf, format, 2);		/* per-column formats */
  		pq_endmessage(&buf);
--- 403,429 ----
  		/* new way */
  		StringInfoData buf;
  		int			natts = list_length(cstate->attnumlist);
! 		int16		format;
! 		int			mode;
  		int			i;
  
  		pq_beginmessage(&buf, 'G');
! 
! 		if (cstate->raw)
! 			mode = 2;
! 		else if (cstate->binary)
! 			mode = 1;
! 		else
! 			mode = 0;
! 
! 		pq_sendbyte(&buf, mode);		/* overall format */
  		pq_sendint(&buf, natts, 2);
+ 
+ 		if (!cstate->raw)
+ 			format = cstate->binary ? 1 : 0;
+ 		else
+ 			format = cstate->binary ? 3 : 2;
+ 
  		for (i = 0; i < natts; i++)
  			pq_sendint(&buf, format, 2);		/* per-column formats */
  		pq_endmessage(&buf);
*************** ReceiveCopyBegin(CopyState cstate)
*** 402,411 ****
  	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
  	{
  		/* old way */
! 		if (cstate->binary)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 			errmsg("COPY BINARY is not supported to stdout or from stdin")));
  		pq_putemptymessage('G');
  		/* any error in old protocol will make us lose sync */
  		pq_startmsgread();
--- 433,442 ----
  	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
  	{
  		/* old way */
! 		if (cstate->binary || cstate->raw)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 			errmsg("COPY BINARY or COPY RAW_TEXT/RAW_BINARY is not supported to stdout or from stdin")));
  		pq_putemptymessage('G');
  		/* any error in old protocol will make us lose sync */
  		pq_startmsgread();
*************** ReceiveCopyBegin(CopyState cstate)
*** 414,423 ****
  	else
  	{
  		/* very old way */
! 		if (cstate->binary)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 			errmsg("COPY BINARY is not supported to stdout or from stdin")));
  		pq_putemptymessage('D');
  		/* any error in old protocol will make us lose sync */
  		pq_startmsgread();
--- 445,454 ----
  	else
  	{
  		/* very old way */
! 		if (cstate->binary || cstate->raw)
  			ereport(ERROR,
  					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 			errmsg("COPY BINARY or COPY RAW_TEXT/RAW_BINARY is not supported to stdout or from stdin")));
  		pq_putemptymessage('D');
  		/* any error in old protocol will make us lose sync */
  		pq_startmsgread();
*************** CopySendEndOfRow(CopyState cstate)
*** 482,488 ****
  	switch (cstate->copy_dest)
  	{
  		case COPY_FILE:
! 			if (!cstate->binary)
  			{
  				/* Default line termination depends on platform */
  #ifndef WIN32
--- 513,519 ----
  	switch (cstate->copy_dest)
  	{
  		case COPY_FILE:
! 			if (!cstate->binary && !cstate->raw)
  			{
  				/* Default line termination depends on platform */
  #ifndef WIN32
*************** CopySendEndOfRow(CopyState cstate)
*** 526,531 ****
--- 557,565 ----
  			}
  			break;
  		case COPY_OLD_FE:
+ 			/* This old protocol doesn't allow RAW_TEXT/RAW_BINARY */
+ 			Assert(!cstate->raw);
+ 
  			/* The FE/BE protocol uses \n as newline for all platforms */
  			if (!cstate->binary)
  				CopySendChar(cstate, '\n');
*************** CopySendEndOfRow(CopyState cstate)
*** 540,546 ****
  			break;
  		case COPY_NEW_FE:
  			/* The FE/BE protocol uses \n as newline for all platforms */
! 			if (!cstate->binary)
  				CopySendChar(cstate, '\n');
  
  			/* Dump the accumulated row as one CopyData message */
--- 574,580 ----
  			break;
  		case COPY_NEW_FE:
  			/* The FE/BE protocol uses \n as newline for all platforms */
! 			if (!cstate->binary && !cstate->raw)
  				CopySendChar(cstate, '\n');
  
  			/* Dump the accumulated row as one CopyData message */
*************** CopyLoadRawBuf(CopyState cstate)
*** 766,771 ****
--- 800,837 ----
  	return (inbytes > 0);
  }
  
+ /*
+  * CopyLoadallRawBuf loads all content into raw_buf.
+  *
+  * This routine is used in raw_text/raw_binary mode. If original RAW_BUF_SIZE is not
+  * enough, then the buffer is enlarged.
+  */
+ static void
+ CopyLoadallRawBuf(CopyState cstate)
+ {
+ 	int			nbytes = 0;
+ 	int			inbytes;
+ 	Size		raw_buf_size = RAW_BUF_SIZE;
+ 
+ 	do
+ 	{
+ 		/* hold enough space for one data packet */
+ 		if ((raw_buf_size - nbytes - 1) < 8 * 1024)
+ 		{
+ 			raw_buf_size += RAW_BUF_SIZE;
+ 			cstate->raw_buf = repalloc(cstate->raw_buf, raw_buf_size);
+ 		}
+ 
+ 		inbytes = CopyGetData(cstate, cstate->raw_buf + nbytes, 1, raw_buf_size - nbytes - 1);
+ 		nbytes += inbytes;
+ 	}
+ 	while (inbytes > 0);
+ 
+ 	cstate->raw_buf[nbytes] = '\0';
+ 	cstate->raw_buf_index = 0;
+ 	cstate->raw_buf_len = nbytes;
+ }
+ 
  
  /*
   *	 DoCopy executes the SQL COPY statement
*************** ProcessCopyOptions(CopyState cstate,
*** 1013,1018 ****
--- 1079,1091 ----
  				cstate->csv_mode = true;
  			else if (strcmp(fmt, "binary") == 0)
  				cstate->binary = true;
+ 			else if (strcmp(fmt, "raw_text") == 0)
+ 				cstate->raw = true;
+ 			else if (strcmp(fmt, "raw_binary") == 0)
+ 			{
+ 				cstate->binary = true;
+ 				cstate->raw = true;
+ 			}
  			else
  				ereport(ERROR,
  						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
*************** ProcessCopyOptions(CopyState cstate,
*** 1162,1177 ****
  	 * Check for incompatible options (must do these two before inserting
  	 * defaults)
  	 */
! 	if (cstate->binary && cstate->delim)
  		ereport(ERROR,
  				(errcode(ERRCODE_SYNTAX_ERROR),
  				 errmsg("cannot specify DELIMITER in BINARY mode")));
  
! 	if (cstate->binary && cstate->null_print)
  		ereport(ERROR,
  				(errcode(ERRCODE_SYNTAX_ERROR),
  				 errmsg("cannot specify NULL in BINARY mode")));
  
  	/* Set defaults for omitted options */
  	if (!cstate->delim)
  		cstate->delim = cstate->csv_mode ? "," : "\t";
--- 1235,1255 ----
  	 * Check for incompatible options (must do these two before inserting
  	 * defaults)
  	 */
! 	if ((cstate->binary || cstate->raw)  && cstate->delim)
  		ereport(ERROR,
  				(errcode(ERRCODE_SYNTAX_ERROR),
  				 errmsg("cannot specify DELIMITER in BINARY mode")));
  
! 	if ((cstate->binary || cstate->raw) && cstate->null_print)
  		ereport(ERROR,
  				(errcode(ERRCODE_SYNTAX_ERROR),
  				 errmsg("cannot specify NULL in BINARY mode")));
  
+ 	if (cstate->raw && cstate->oids)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_SYNTAX_ERROR),
+ 				 errmsg("cannot specify OIDS in RAW_TEXT/RAW_BINARY mode")));
+ 
  	/* Set defaults for omitted options */
  	if (!cstate->delim)
  		cstate->delim = cstate->csv_mode ? "," : "\t";
*************** BeginCopy(bool is_from,
*** 1608,1613 ****
--- 1686,1697 ----
  		}
  	}
  
+ 	/* No more columns are allowed in RAW mode */
+ 	if (cstate->raw && list_length(cstate->attnumlist) > 1)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 		 errmsg("Single column result/target is required in RAW_TEXT/RAW_BINARY mode")));
+ 
  	/* Use client encoding when ENCODING option is not specified. */
  	if (cstate->file_encoding < 0)
  		cstate->file_encoding = pg_get_client_encoding();
*************** CopyTo(CopyState cstate)
*** 1899,1905 ****
  											   ALLOCSET_DEFAULT_INITSIZE,
  											   ALLOCSET_DEFAULT_MAXSIZE);
  
! 	if (cstate->binary)
  	{
  		/* Generate header for a binary copy */
  		int32		tmp;
--- 1983,1989 ----
  											   ALLOCSET_DEFAULT_INITSIZE,
  											   ALLOCSET_DEFAULT_MAXSIZE);
  
! 	if (cstate->binary && !cstate->raw)
  	{
  		/* Generate header for a binary copy */
  		int32		tmp;
*************** CopyTo(CopyState cstate)
*** 1931,1936 ****
--- 2015,2023 ----
  		{
  			bool		hdr_delim = false;
  
+ 			/* raw_text/raw_binary mode is not allowed here */
+ 			Assert(!cstate->raw);
+ 
  			foreach(cur, cstate->attnumlist)
  			{
  				int			attnum = lfirst_int(cur);
*************** CopyTo(CopyState cstate)
*** 1967,1972 ****
--- 2054,2063 ----
  		{
  			CHECK_FOR_INTERRUPTS();
  
+ 			/* stop quickly in raw_text/raw_binary when more rows is detected */
+ 			if (cstate->raw && processed > 0)
+ 				break;
+ 
  			/* Deconstruct the tuple ... faster than repeated heap_getattr */
  			heap_deform_tuple(tuple, tupDesc, values, nulls);
  
*************** CopyTo(CopyState cstate)
*** 1983,1993 ****
  	else
  	{
  		/* run the plan --- the dest receiver will send tuples */
! 		ExecutorRun(cstate->queryDesc, ForwardScanDirection, 0L);
  		processed = ((DR_copy *) cstate->queryDesc->dest)->processed;
  	}
  
! 	if (cstate->binary)
  	{
  		/* Generate trailer for a binary copy */
  		CopySendInt16(cstate, -1);
--- 2074,2098 ----
  	else
  	{
  		/* run the plan --- the dest receiver will send tuples */
! 		ExecutorRun(cstate->queryDesc, ForwardScanDirection, cstate->raw ? 2L : 0L);
  		processed = ((DR_copy *) cstate->queryDesc->dest)->processed;
  	}
  
! 	/* raw_text/raw_binary requires exactly one row */
! 	if (cstate->raw)
! 	{
! 		if (processed > 1)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_TOO_MANY_ROWS),
! 					 errmsg("single row result is required by RAW_TEXT/RAW_BINARY mode")));
! 
! 		if (processed == 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_NO_DATA_FOUND),
! 					 errmsg("single row result is required by RAW_TEXT/RAW_BINARY mode")));
! 	}
! 
! 	if (cstate->binary && !cstate->raw)
  	{
  		/* Generate trailer for a binary copy */
  		CopySendInt16(cstate, -1);
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 2015,2042 ****
  	MemoryContextReset(cstate->rowcontext);
  	oldcontext = MemoryContextSwitchTo(cstate->rowcontext);
  
! 	if (cstate->binary)
  	{
! 		/* Binary per-tuple header */
! 		CopySendInt16(cstate, list_length(cstate->attnumlist));
! 		/* Send OID if wanted --- note attnumlist doesn't include it */
! 		if (cstate->oids)
  		{
! 			/* Hack --- assume Oid is same size as int32 */
! 			CopySendInt32(cstate, sizeof(int32));
! 			CopySendInt32(cstate, tupleOid);
  		}
! 	}
! 	else
! 	{
! 		/* Text format has no per-tuple header, but send OID if wanted */
! 		/* Assume digits don't need any quoting or encoding conversion */
! 		if (cstate->oids)
  		{
! 			string = DatumGetCString(DirectFunctionCall1(oidout,
! 												ObjectIdGetDatum(tupleOid)));
! 			CopySendString(cstate, string);
! 			need_delim = true;
  		}
  	}
  
--- 2120,2150 ----
  	MemoryContextReset(cstate->rowcontext);
  	oldcontext = MemoryContextSwitchTo(cstate->rowcontext);
  
! 	if (!cstate->raw)
  	{
! 		if (cstate->binary)
  		{
! 			/* Binary per-tuple header */
! 			CopySendInt16(cstate, list_length(cstate->attnumlist));
! 			/* Send OID if wanted --- note attnumlist doesn't include it */
! 			if (cstate->oids)
! 			{
! 				/* Hack --- assume Oid is same size as int32 */
! 				CopySendInt32(cstate, sizeof(int32));
! 				CopySendInt32(cstate, tupleOid);
! 			}
  		}
! 		else
  		{
! 			/* Text format has no per-tuple header, but send OID if wanted */
! 			/* Assume digits don't need any quoting or encoding conversion */
! 			if (cstate->oids)
! 			{
! 				string = DatumGetCString(DirectFunctionCall1(oidout,
! 													ObjectIdGetDatum(tupleOid)));
! 				CopySendString(cstate, string);
! 				need_delim = true;
! 			}
  		}
  	}
  
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 2055,2060 ****
--- 2163,2173 ----
  
  		if (isnull)
  		{
+ 			if (cstate->raw)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+ 						 errmsg("NULL value is not allowed in RAW_TEXT/RAW_BINARY mode")));
+ 
  			if (!cstate->binary)
  				CopySendString(cstate, cstate->null_print_client);
  			else
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 2062,2068 ****
  		}
  		else
  		{
! 			if (!cstate->binary)
  			{
  				string = OutputFunctionCall(&out_functions[attnum - 1],
  											value);
--- 2175,2246 ----
  		}
  		else
  		{
! 			if (cstate->raw)
! 			{
! 				const void *content;
! 				int size;
! 			
! 				if (!cstate->binary)
! 				{
! 					string = OutputFunctionCall(&out_functions[attnum - 1],
! 												value);
! 
! 					/* We would to transcode, but without escaping */
! 					if (cstate->need_transcoding)
! 						content = pg_server_to_any(string, strlen(string), cstate->file_encoding);
! 					else
! 						content = string;
! 
! 					size = strlen((const char *) content);
! 				}
! 				else
! 				{
! 					bytea *outputbytes;
! 
! 					/*
! 					 * Some binary output functions depends can depends on client encoding.
! 					 * The binary output of xml is good example. Set client_encoding
! 					 * temporaly before out function execution.
! 					 */
! 					if (cstate->need_transcoding)
! 					{
! 						int		old_server_encoding = pg_get_client_encoding();
! 						volatile bool reset_encoding = false;
! 
! 						PG_TRY();
! 						{
! 							/* We don't expect an error, because encoding was checked before */
! 							if (PrepareClientEncoding(cstate->file_encoding) < 0)
! 								elog(ERROR, "PrepareClientEncoding(%d) failed", cstate->file_encoding);
! 
! 							SetClientEncoding(cstate->file_encoding);
! 							reset_encoding = true;
! 
! 							outputbytes = SendFunctionCall(&out_functions[attnum - 1],
! 													   value);
! 							SetClientEncoding(old_server_encoding);
! 						}
! 						PG_CATCH();
! 						{
! 							if (reset_encoding)
! 								SetClientEncoding(old_server_encoding);
! 							PG_RE_THROW();
! 						}
! 						PG_END_TRY();
! 					}
! 					else
! 					{
! 						outputbytes = SendFunctionCall(&out_functions[attnum - 1],
! 												   value);
! 					}
! 					content = VARDATA(outputbytes);
! 					size = VARSIZE(outputbytes) - VARHDRSZ;
! 				}
! 
! 				/* Send only content in RAW_TEXT/RAW_BINARY mode */
! 				CopySendData(cstate, content, size);
! 			}
! 			else if (!cstate->binary)
  			{
  				string = OutputFunctionCall(&out_functions[attnum - 1],
  											value);
*************** BeginCopyFrom(Relation rel,
*** 2811,2875 ****
  		}
  	}
  
! 	if (!cstate->binary)
! 	{
! 		/* must rely on user to tell us... */
! 		cstate->file_has_oids = cstate->oids;
! 	}
! 	else
  	{
! 		/* Read and verify binary header */
! 		char		readSig[11];
! 		int32		tmp;
! 
! 		/* Signature */
! 		if (CopyGetData(cstate, readSig, 11, 11) != 11 ||
! 			memcmp(readSig, BinarySignature, 11) != 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("COPY file signature not recognized")));
! 		/* Flags field */
! 		if (!CopyGetInt32(cstate, &tmp))
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("invalid COPY file header (missing flags)")));
! 		cstate->file_has_oids = (tmp & (1 << 16)) != 0;
! 		tmp &= ~(1 << 16);
! 		if ((tmp >> 16) != 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 				 errmsg("unrecognized critical flags in COPY file header")));
! 		/* Header extension length */
! 		if (!CopyGetInt32(cstate, &tmp) ||
! 			tmp < 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("invalid COPY file header (missing length)")));
! 		/* Skip extension header, if present */
! 		while (tmp-- > 0)
  		{
! 			if (CopyGetData(cstate, readSig, 1, 1) != 1)
  				ereport(ERROR,
  						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("invalid COPY file header (wrong length)")));
  		}
- 	}
  
! 	if (cstate->file_has_oids && cstate->binary)
! 	{
! 		getTypeBinaryInputInfo(OIDOID,
! 							   &in_func_oid, &cstate->oid_typioparam);
! 		fmgr_info(in_func_oid, &cstate->oid_in_function);
! 	}
  
! 	/* create workspace for CopyReadAttributes results */
! 	if (!cstate->binary)
! 	{
! 		AttrNumber	attr_count = list_length(cstate->attnumlist);
! 		int			nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
  
! 		cstate->max_fields = nfields;
! 		cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
  	}
  
  	MemoryContextSwitchTo(oldcontext);
--- 2989,3057 ----
  		}
  	}
  
! 	/* The raw mode hasn't any header information */
! 	if (!cstate->raw)
  	{
! 		if (!cstate->binary)
  		{
! 			/* must rely on user to tell us... */
! 			cstate->file_has_oids = cstate->oids;
! 		}
! 		else
! 		{
! 			/* Read and verify binary header */
! 			char		readSig[11];
! 			int32		tmp;
! 
! 			/* Signature */
! 			if (CopyGetData(cstate, readSig, 11, 11) != 11 ||
! 				memcmp(readSig, BinarySignature, 11) != 0)
  				ereport(ERROR,
  						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("COPY file signature not recognized")));
! 			/* Flags field */
! 			if (!CopyGetInt32(cstate, &tmp))
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("invalid COPY file header (missing flags)")));
! 			cstate->file_has_oids = (tmp & (1 << 16)) != 0;
! 			tmp &= ~(1 << 16);
! 			if ((tmp >> 16) != 0)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("unrecognized critical flags in COPY file header")));
! 			/* Header extension length */
! 			if (!CopyGetInt32(cstate, &tmp) ||
! 				tmp < 0)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("invalid COPY file header (missing length)")));
! 			/* Skip extension header, if present */
! 			while (tmp-- > 0)
! 			{
! 				if (CopyGetData(cstate, readSig, 1, 1) != 1)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							 errmsg("invalid COPY file header (wrong length)")));
! 			}
  		}
  
! 		if (cstate->file_has_oids && cstate->binary)
! 		{
! 			getTypeBinaryInputInfo(OIDOID,
! 								   &in_func_oid, &cstate->oid_typioparam);
! 			fmgr_info(in_func_oid, &cstate->oid_in_function);
! 		}
  
! 		/* create workspace for CopyReadAttributes results */
! 		if (!cstate->binary)
! 		{
! 			AttrNumber	attr_count = list_length(cstate->attnumlist);
! 			int			nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
  
! 			cstate->max_fields = nfields;
! 			cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
! 		}
  	}
  
  	MemoryContextSwitchTo(oldcontext);
*************** NextCopyFrom(CopyState cstate, ExprConte
*** 2968,2974 ****
  	MemSet(values, 0, num_phys_attrs * sizeof(Datum));
  	MemSet(nulls, true, num_phys_attrs * sizeof(bool));
  
! 	if (!cstate->binary)
  	{
  		char	  **field_strings;
  		ListCell   *cur;
--- 3150,3203 ----
  	MemSet(values, 0, num_phys_attrs * sizeof(Datum));
  	MemSet(nulls, true, num_phys_attrs * sizeof(bool));
  
! 	if (cstate->raw)
! 	{
! 		int		m = linitial_int(cstate->attnumlist) - 1;
! 
! 		/* All content was read in first cycle */
! 		if (++cstate->cur_lineno > 1)
! 			return false;
! 
! 		CopyLoadallRawBuf(cstate);
! 
! 		cstate->cur_attname = NameStr(attr[m]->attname);
! 
! 		if (!cstate->binary)
! 		{
! 			char	   *cvt;
! 
! 			cvt = pg_any_to_server(cstate->raw_buf,
! 								   cstate->raw_buf_len,
! 								   cstate->file_encoding);
! 
! 			values[m] = InputFunctionCall(&in_functions[m],
! 										  cvt,
! 										  typioparams[m],
! 										  attr[m]->atttypmod);
! 		}
! 		else
! 		{
! 			cstate->attribute_buf.data = cstate->raw_buf;
! 			cstate->attribute_buf.len = cstate->raw_buf_len;
! 			cstate->attribute_buf.cursor = 0;
! 			cstate->raw_buf = NULL;
! 
! 			/* Call the column type's binary input converter */
! 			values[m] = ReceiveFunctionCall(&in_functions[m], &cstate->attribute_buf,
! 									 typioparams[m], attr[m]->atttypmod);
! 
! 			/* Trouble if it didn't eat the whole buffer */
! 			if (cstate->attribute_buf.cursor != cstate->attribute_buf.len)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
! 						 errmsg("incorrect binary data format")));
! 		}
! 
! 		nulls[m] = false;
! 
! 		cstate->cur_attname = NULL;
! 	}
! 	else if (!cstate->binary)
  	{
  		char	  **field_strings;
  		ListCell   *cur;
diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c
new file mode 100644
index cb8a06d..4dab119
*** a/src/bin/psql/tab-complete.c
--- b/src/bin/psql/tab-complete.c
*************** psql_completion(const char *text, int st
*** 1969,1976 ****
  	/* Handle COPY [BINARY] <sth> FROM|TO filename */
  	else if (Matches4("COPY|\\copy", MatchAny, "FROM|TO", MatchAny) ||
  			 Matches5("COPY", "BINARY", MatchAny, "FROM|TO", MatchAny))
! 		COMPLETE_WITH_LIST6("BINARY", "OIDS", "DELIMITER", "NULL", "CSV",
! 							"ENCODING");
  
  	/* Handle COPY [BINARY] <sth> FROM|TO filename CSV */
  	else if (Matches5("COPY|\\copy", MatchAny, "FROM|TO", MatchAny, "CSV") ||
--- 1969,1976 ----
  	/* Handle COPY [BINARY] <sth> FROM|TO filename */
  	else if (Matches4("COPY|\\copy", MatchAny, "FROM|TO", MatchAny) ||
  			 Matches5("COPY", "BINARY", MatchAny, "FROM|TO", MatchAny))
! 		COMPLETE_WITH_LIST8("BINARY", "RAW_TEXT", "RAW_BINARY", "OIDS",
! 							"DELIMITER", "NULL", "CSV", "ENCODING");
  
  	/* Handle COPY [BINARY] <sth> FROM|TO filename CSV */
  	else if (Matches5("COPY|\\copy", MatchAny, "FROM|TO", MatchAny, "CSV") ||
diff --git a/src/interfaces/libpq/exports.txt b/src/interfaces/libpq/exports.txt
new file mode 100644
index 21dd772..a2754f1
*** a/src/interfaces/libpq/exports.txt
--- b/src/interfaces/libpq/exports.txt
*************** PQsslAttributeNames       168
*** 171,173 ****
--- 171,174 ----
  PQsslAttribute            169
  PQsetErrorContextVisibility 170
  PQresultVerboseErrorMessage 171
+ PQcopyFormat              172
diff --git a/src/interfaces/libpq/fe-exec.c b/src/interfaces/libpq/fe-exec.c
new file mode 100644
index 2621767..09967e9
*** a/src/interfaces/libpq/fe-exec.c
--- b/src/interfaces/libpq/fe-exec.c
*************** PQmakeEmptyPGresult(PGconn *conn, ExecSt
*** 155,160 ****
--- 155,161 ----
  	result->resultStatus = status;
  	result->cmdStatus[0] = '\0';
  	result->binary = 0;
+ 	result->raw = 0;
  	result->events = NULL;
  	result->nEvents = 0;
  	result->errMsg = NULL;
*************** PQsetResultAttrs(PGresult *res, int numA
*** 256,263 ****
  		if (!res->attDescs[i].name)
  			return FALSE;
  
! 		if (res->attDescs[i].format == 0)
  			res->binary = 0;
  	}
  
  	return TRUE;
--- 257,266 ----
  		if (!res->attDescs[i].name)
  			return FALSE;
  
! 		if (res->attDescs[i].format == 0 || res->attDescs[i].format == 2)
  			res->binary = 0;
+ 		if (res->attDescs[i].format == 2 || res->attDescs[i].format == 3)
+ 			res->raw = 1;
  	}
  
  	return TRUE;
*************** PQcmdStatus(PGresult *res)
*** 2932,2937 ****
--- 2935,2955 ----
  }
  
  /*
+  * PQcopyFormat
+  *
+  * Returns a info about copy mode:
+  * -1 signalize a error, 0 = text mode, 1 = binary mode, 2 = raw mode
+  */
+ int
+ PQcopyFormat(const PGresult *res)
+ {
+ 	if (res->raw)
+ 		return 2;
+ 	else
+ 		return res->binary;
+ }
+ 
+ /*
   * PQoidStatus -
   *	if the last command was an INSERT, return the oid string
   *	if not, return ""
diff --git a/src/interfaces/libpq/fe-protocol3.c b/src/interfaces/libpq/fe-protocol3.c
new file mode 100644
index 0b8c62f..1783844
*** a/src/interfaces/libpq/fe-protocol3.c
--- b/src/interfaces/libpq/fe-protocol3.c
*************** getCopyStart(PGconn *conn, ExecStatusTyp
*** 1486,1491 ****
--- 1486,1495 ----
  		 */
  		format = (int) ((int16) format);
  		result->attDescs[i].format = format;
+ 
+ 		/* when any field uses raw format, then COPY RAW_* was used */
+ 		if (format == 2 || format == 3)
+ 			result->raw = true;
  	}
  
  	/* Success! */
diff --git a/src/interfaces/libpq/libpq-fe.h b/src/interfaces/libpq/libpq-fe.h
new file mode 100644
index 9ca0756..7984666
*** a/src/interfaces/libpq/libpq-fe.h
--- b/src/interfaces/libpq/libpq-fe.h
*************** extern Oid	PQftype(const PGresult *res,
*** 479,484 ****
--- 479,485 ----
  extern int	PQfsize(const PGresult *res, int field_num);
  extern int	PQfmod(const PGresult *res, int field_num);
  extern char *PQcmdStatus(PGresult *res);
+ extern int	PQcopyFormat(const PGresult *res);
  extern char *PQoidStatus(const PGresult *res);	/* old and ugly */
  extern Oid	PQoidValue(const PGresult *res);	/* new and improved */
  extern char *PQcmdTuples(PGresult *res);
diff --git a/src/interfaces/libpq/libpq-int.h b/src/interfaces/libpq/libpq-int.h
new file mode 100644
index 1183323..8fc4b04
*** a/src/interfaces/libpq/libpq-int.h
--- b/src/interfaces/libpq/libpq-int.h
*************** struct pg_result
*** 180,185 ****
--- 180,186 ----
  	char		cmdStatus[CMDSTATUS_LEN];		/* cmd status from the query */
  	int			binary;			/* binary tuple values if binary == 1,
  								 * otherwise text */
+ 	int			raw;			/* raw mode for COPY */
  
  	/*
  	 * These fields are copied from the originating PGconn, so that operations
diff --git a/src/test/regress/expected/copy2.out b/src/test/regress/expected/copy2.out
new file mode 100644
index 5f6260a..3d36dd3
*** a/src/test/regress/expected/copy2.out
--- b/src/test/regress/expected/copy2.out
*************** DROP FUNCTION truncate_in_subxact();
*** 466,468 ****
--- 466,482 ----
  DROP TABLE x, y;
  DROP FUNCTION fn_x_before();
  DROP FUNCTION fn_x_after();
+ CREATE TABLE x(a bytea);
+ INSERT INTO x VALUES('\x41484f4a0a');
+ INSERT INTO x VALUES('\x41484f4a0a');
+ -- should to fail
+ COPY (SELECT a,a FROM x LIMIT 1) TO STDOUT (FORMAT raw_binary);
+ ERROR:  Single column result/target is required in RAW_TEXT/RAW_BINARY mode
+ COPY (SELECT a FROM x) TO STDOUT (FORMAT raw_binary);
+ AHOJ
+ AHOJ
+ ERROR:  single row result is required by RAW_TEXT/RAW_BINARY mode
+ -- should be ok
+ COPY (SELECT a FROM x LIMIT 1) TO STDOUT (FORMAT raw_binary);
+ AHOJ
+ DROP TABLE x;
diff --git a/src/test/regress/input/copy.source b/src/test/regress/input/copy.source
new file mode 100644
index cb13606..085ae36
*** a/src/test/regress/input/copy.source
--- b/src/test/regress/input/copy.source
*************** this is just a line full of junk that wo
*** 133,135 ****
--- 133,214 ----
  \.
  
  copy copytest3 to stdout csv header;
+ 
+ -- copy raw
+ CREATE TABLE x(a bytea);
+ INSERT INTO x VALUES('\x41484f4a0a');
+ SELECT length(a) FROM x;
+ 
+ INSERT INTO x VALUES('\x41484f4a0a');
+ 
+ -- should to fail
+ COPY (SELECT a,a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ COPY (SELECT a FROM x) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ 
+ -- should be ok
+ COPY (SELECT a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ TRUNCATE x;
+ COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ SELECT length(a) FROM x;
+ COPY x TO stdout (FORMAT raw_binary);
+ 
+ TRUNCATE x;
+ 
+ \COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw_binary)
+ SELECT length(a) FROM x;
+ COPY x TO stdout (FORMAT raw_binary);
+ 
+ \COPY x TO '@abs_builddir@/results/raw2.data' (FORMAT raw_binary)
+ TRUNCATE x;
+ 
+ \COPY x FROM '@abs_builddir@/results/raw2.data' (FORMAT raw_binary)
+ SELECT length(a) FROM x;
+ COPY x TO stdout (FORMAT raw_binary);
+ 
+ -- test big file
+ TRUNCATE x;
+ -- use different mechanism for load to bytea
+ \lo_import @abs_builddir@/data/hash.data
+ \set lo_oid :LASTOID
+ INSERT INTO x VALUES(lo_get(:lo_oid));
+ \lo_unlink :lo_oid
+ 
+ COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary);
+ \COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary)
+ 
+ SELECT md5(a), length(a) FROM x;
+ 
+ TRUNCATE x;
+ COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary);
+ COPY x TO '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+ \COPY x TO '@abs_builddir@/results/hash3.data' (FORMAT raw_binary)
+ 
+ -- read again
+ COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+ \COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw_binary)
+ -- cross
+ COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw_binary);
+ \COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary)
+ 
+ SELECT md5(a), length(a) FROM x;
+ 
+ DROP TABLE x;
+ 
+ -- insert into multicolumn table
+ CREATE TABLE x(id serial, a bytea, b bytea);
+ 
+ -- should fail, too much columns
+ COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+ 
+ -- should work
+ COPY x(a) FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+ COPY x(b) FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+ SELECT id, md5(a), md5(b) FROM x;
+ 
+ -- test raw_text
+ COPY (SELECT a FROM x WHERE id = 1) TO '@abs_builddir@/results/hash4.data' (FORMAT raw_text);
+ COPY x(a) FROM '@abs_builddir@/results/hash4.data' (FORMAT raw_text);
+ SELECT id, md5(a) FROM x WHERE id = lastval();
+ 
+ DROP TABLE x;
+ 
diff --git a/src/test/regress/output/copy.source b/src/test/regress/output/copy.source
new file mode 100644
index b7e372d..e34bbab
*** a/src/test/regress/output/copy.source
--- b/src/test/regress/output/copy.source
*************** copy copytest3 to stdout csv header;
*** 95,97 ****
--- 95,208 ----
  c1,"col with , comma","col with "" quote"
  1,a,1
  2,b,2
+ -- copy raw
+ CREATE TABLE x(a bytea);
+ INSERT INTO x VALUES('\x41484f4a0a');
+ SELECT length(a) FROM x;
+  length 
+ --------
+       5
+ (1 row)
+ 
+ INSERT INTO x VALUES('\x41484f4a0a');
+ -- should to fail
+ COPY (SELECT a,a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ ERROR:  Single column result/target is required in RAW_TEXT/RAW_BINARY mode
+ COPY (SELECT a FROM x) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ ERROR:  single row result is required by RAW_TEXT/RAW_BINARY mode
+ -- should be ok
+ COPY (SELECT a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ TRUNCATE x;
+ COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ SELECT length(a) FROM x;
+  length 
+ --------
+       5
+ (1 row)
+ 
+ COPY x TO stdout (FORMAT raw_binary);
+ AHOJ
+ TRUNCATE x;
+ \COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw_binary)
+ SELECT length(a) FROM x;
+  length 
+ --------
+       5
+ (1 row)
+ 
+ COPY x TO stdout (FORMAT raw_binary);
+ AHOJ
+ \COPY x TO '@abs_builddir@/results/raw2.data' (FORMAT raw_binary)
+ TRUNCATE x;
+ \COPY x FROM '@abs_builddir@/results/raw2.data' (FORMAT raw_binary)
+ SELECT length(a) FROM x;
+  length 
+ --------
+       5
+ (1 row)
+ 
+ COPY x TO stdout (FORMAT raw_binary);
+ AHOJ
+ -- test big file
+ TRUNCATE x;
+ -- use different mechanism for load to bytea
+ \lo_import @abs_builddir@/data/hash.data
+ \set lo_oid :LASTOID
+ INSERT INTO x VALUES(lo_get(:lo_oid));
+ \lo_unlink :lo_oid
+ COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary);
+ \COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary)
+ SELECT md5(a), length(a) FROM x;
+                md5                | length 
+ ----------------------------------+--------
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+ (3 rows)
+ 
+ TRUNCATE x;
+ COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary);
+ COPY x TO '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+ \COPY x TO '@abs_builddir@/results/hash3.data' (FORMAT raw_binary)
+ -- read again
+ COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+ \COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw_binary)
+ -- cross
+ COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw_binary);
+ \COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary)
+ SELECT md5(a), length(a) FROM x;
+                md5                | length 
+ ----------------------------------+--------
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+  e446fe6ea5a347e69670633412c7f8cb | 153749
+ (5 rows)
+ 
+ DROP TABLE x;
+ -- insert into multicolumn table
+ CREATE TABLE x(id serial, a bytea, b bytea);
+ -- should fail, too much columns
+ COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+ ERROR:  Single column result/target is required in RAW_TEXT/RAW_BINARY mode
+ -- should work
+ COPY x(a) FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+ COPY x(b) FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+ SELECT id, md5(a), md5(b) FROM x;
+  id |               md5                |               md5                
+ ----+----------------------------------+----------------------------------
+   1 | e446fe6ea5a347e69670633412c7f8cb | 
+   2 |                                  | e446fe6ea5a347e69670633412c7f8cb
+ (2 rows)
+ 
+ -- test raw_text
+ COPY (SELECT a FROM x WHERE id = 1) TO '@abs_builddir@/results/hash4.data' (FORMAT raw_text);
+ COPY x(a) FROM '@abs_builddir@/results/hash4.data' (FORMAT raw_text);
+ SELECT id, md5(a) FROM x WHERE id = lastval();
+  id |               md5                
+ ----+----------------------------------
+   3 | e446fe6ea5a347e69670633412c7f8cb
+ (1 row)
+ 
+ DROP TABLE x;
diff --git a/src/test/regress/sql/copy2.sql b/src/test/regress/sql/copy2.sql
new file mode 100644
index 39a9deb..7e22ee4
*** a/src/test/regress/sql/copy2.sql
--- b/src/test/regress/sql/copy2.sql
*************** DROP FUNCTION truncate_in_subxact();
*** 333,335 ****
--- 333,348 ----
  DROP TABLE x, y;
  DROP FUNCTION fn_x_before();
  DROP FUNCTION fn_x_after();
+ 
+ CREATE TABLE x(a bytea);
+ INSERT INTO x VALUES('\x41484f4a0a');
+ INSERT INTO x VALUES('\x41484f4a0a');
+ 
+ -- should to fail
+ COPY (SELECT a,a FROM x LIMIT 1) TO STDOUT (FORMAT raw_binary);
+ COPY (SELECT a FROM x) TO STDOUT (FORMAT raw_binary);
+ 
+ -- should be ok
+ COPY (SELECT a FROM x LIMIT 1) TO STDOUT (FORMAT raw_binary);
+ 
+ DROP TABLE x;

commit d62c1ff8dee2324ce1fe7765c2d015e68f5f923a
Author: Pavel Stehule <pavel.stehule@gooddata.com>
Date:   Sat Jul 16 10:35:25 2016 +0200

    with regress tests

diff --git a/doc/src/sgml/libpq.sgml b/doc/src/sgml/libpq.sgml
index 6285dd0..4c6cacb 100644
--- a/doc/src/sgml/libpq.sgml
+++ b/doc/src/sgml/libpq.sgml
@@ -3226,8 +3226,9 @@ int PQfformat(const PGresult *res,
 
       <para>
        Format code zero indicates textual data representation, while format
-       code one indicates binary representation.  (Other codes are reserved
-       for future definition.)
+       code one indicates binary representation. Format code two indicates
+       raw_text representation and format code three indicates raw_binary
+       representation (Other codes are reserved for future definition.)
       </para>
      </listitem>
     </varlistentry>
@@ -3557,6 +3558,26 @@ typedef struct
    </para>
 
    <variablelist>
+    <varlistentry id="libpq-pqcopyformat">
+     <term>
+      <function>PQcopyFormat</function>
+      <indexterm>
+       <primary>PQcopyFormat</primary>
+      </indexterm>
+     </term>
+
+     <listitem>
+      <para>
+       Format code zero indicates textual data representation, format one
+       indicates binary representation, format two indicates raw
+       representation.
+<synopsis>
+int PQcopyFormat(PGresult *res);
+</synopsis>
+      </para>
+     </listitem>
+    </varlistentry>
+
     <varlistentry id="libpq-pqcmdstatus">
      <term>
       <function>PQcmdStatus</function>
diff --git a/doc/src/sgml/protocol.sgml b/doc/src/sgml/protocol.sgml
index 9c96d8f..adcff46 100644
--- a/doc/src/sgml/protocol.sgml
+++ b/doc/src/sgml/protocol.sgml
@@ -3239,6 +3239,7 @@ CopyInResponse (B)
                 characters, etc).
                 1 indicates the overall copy format is binary (similar
                 to DataRow format).
+                2 indicates the overall copy format is raw.
                 See <xref linkend="sql-copy">
                 for more information.
 </para>
@@ -3262,8 +3263,9 @@ CopyInResponse (B)
 <listitem>
 <para>
                 The format codes to be used for each column.
-                Each must presently be zero (text) or one (binary).
-                All must be zero if the overall copy format is textual.
+                Each must be zero (text), one (binary), two (raw_text)
+                or three (raw_binary). All must be zero if the overall
+                copy format is textual.
 </para>
 </listitem>
 </varlistentry>
@@ -3313,7 +3315,8 @@ CopyOutResponse (B)
                 is textual (rows separated by newlines, columns
                 separated by separator characters, etc). 1 indicates
                 the overall copy format is binary (similar to DataRow
-                format). See <xref linkend="sql-copy"> for more information.
+                format). 2 indicates raw_text or raw_binary format.
+                See <xref linkend="sql-copy"> for more information.
 </para>
 </listitem>
 </varlistentry>
@@ -3335,8 +3338,9 @@ CopyOutResponse (B)
 <listitem>
 <para>
                 The format codes to be used for each column.
-                Each must presently be zero (text) or one (binary).
-                All must be zero if the overall copy format is textual.
+                Each must be zero (text), one (binary), two (raw_text)
+                or three (raw_binary). All must be zero if the overall
+                copy format is textual.
 </para>
 </listitem>
 </varlistentry>
diff --git a/doc/src/sgml/ref/copy.sgml b/doc/src/sgml/ref/copy.sgml
index 07e2f45..4e339e4 100644
--- a/doc/src/sgml/ref/copy.sgml
+++ b/doc/src/sgml/ref/copy.sgml
@@ -197,7 +197,9 @@ COPY { <replaceable class="parameter">table_name</replaceable> [ ( <replaceable
       Selects the data format to be read or written:
       <literal>text</>,
       <literal>csv</> (Comma Separated Values),
-      or <literal>binary</>.
+      <literal>binary</>,
+      <literal>raw_text</>
+      or <literal>raw_binary</>.
       The default is <literal>text</>.
      </para>
     </listitem>
@@ -888,6 +890,44 @@ OIDs to be shown as null if that ever proves desirable.
     </para>
    </refsect3>
   </refsect2>
+
+  <refsect2>
+     <title>Raw_text/raw_binary Format</title>
+
+   <para>
+    The <literal>raw_text</literal> format option causes all data to be
+    stored/read as one text value. This format doesn't use any metadata
+    - only raw data are exported or imported.
+   </para>
+
+   <para>
+    The <literal>raw_binary</literal> format option causes all data to be
+    stored/read as binary format rather than as text. It shares format
+    for data with <literal>binary</literal> format. This format doesn't
+    use any metadata - only row data in network byte order are exported
+    or imported.
+   </para>
+
+   <para>
+    Because this format doesn't support any delimiter, only one value
+    can be exported or imported. NULL values are not allowed.
+   </para>
+   <para>
+    The <literal>raw_binary</literal> format can be used for export or import
+    bytea values.
+<programlisting>
+COPY images(data) FROM '/usr1/proj/img/01.jpg' (FORMAT raw_binary);
+</programlisting>
+    It can be used successfully for export XML in different encoding
+    or import valid XML document with any supported encoding:
+<screen><![CDATA[
+SET client_encoding TO latin2;
+
+COPY (SELECT xmlelement(NAME data, 'Hello')) TO stdout (FORMAT raw_binary);
+<?xml version="1.0" encoding="LATIN2"?><data>Hello</data>
+]]></screen>
+   </para>
+  </refsect2>
  </refsect1>
 
  <refsect1>
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index f45b330..c63d052 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -110,6 +110,7 @@ typedef struct CopyStateData
 	char	   *filename;		/* filename, or NULL for STDIN/STDOUT */
 	bool		is_program;		/* is 'filename' a program to popen? */
 	bool		binary;			/* binary format? */
+	bool		raw;			/* raw mode? */
 	bool		oids;			/* include OIDs? */
 	bool		freeze;			/* freeze rows on loading? */
 	bool		csv_mode;		/* Comma Separated Value format? */
@@ -342,12 +343,27 @@ SendCopyBegin(CopyState cstate)
 		/* new way */
 		StringInfoData buf;
 		int			natts = list_length(cstate->attnumlist);
-		int16		format = (cstate->binary ? 1 : 0);
+		int16		format;
+		int			mode;
 		int			i;
 
 		pq_beginmessage(&buf, 'H');
-		pq_sendbyte(&buf, format);		/* overall format */
+
+		if (cstate->raw)
+			mode = 2;
+		else if (cstate->binary)
+			mode = 1;
+		else
+			mode = 0;
+
+		pq_sendbyte(&buf, mode);		/* overall mode */
 		pq_sendint(&buf, natts, 2);
+
+		if (!cstate->raw)
+			format = cstate->binary ? 1 : 0;
+		else
+			format = cstate->binary ? 3 : 2;
+
 		for (i = 0; i < natts; i++)
 			pq_sendint(&buf, format, 2);		/* per-column formats */
 		pq_endmessage(&buf);
@@ -356,10 +372,10 @@ SendCopyBegin(CopyState cstate)
 	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
 	{
 		/* old way */
-		if (cstate->binary)
+		if (cstate->binary || cstate->raw)
 			ereport(ERROR,
 					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-			errmsg("COPY BINARY is not supported to stdout or from stdin")));
+			errmsg("COPY BINARY or COPY RAW_TEXT/RAW_BINARY is not supported to stdout or from stdin")));
 		pq_putemptymessage('H');
 		/* grottiness needed for old COPY OUT protocol */
 		pq_startcopyout();
@@ -368,10 +384,10 @@ SendCopyBegin(CopyState cstate)
 	else
 	{
 		/* very old way */
-		if (cstate->binary)
+		if (cstate->binary || cstate->raw)
 			ereport(ERROR,
 					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-			errmsg("COPY BINARY is not supported to stdout or from stdin")));
+			errmsg("COPY BINARY or COPY RAW_TEXT/RAW_BINARY is not supported to stdout or from stdin")));
 		pq_putemptymessage('B');
 		/* grottiness needed for old COPY OUT protocol */
 		pq_startcopyout();
@@ -387,12 +403,27 @@ ReceiveCopyBegin(CopyState cstate)
 		/* new way */
 		StringInfoData buf;
 		int			natts = list_length(cstate->attnumlist);
-		int16		format = (cstate->binary ? 1 : 0);
+		int16		format;
+		int			mode;
 		int			i;
 
 		pq_beginmessage(&buf, 'G');
-		pq_sendbyte(&buf, format);		/* overall format */
+
+		if (cstate->raw)
+			mode = 2;
+		else if (cstate->binary)
+			mode = 1;
+		else
+			mode = 0;
+
+		pq_sendbyte(&buf, mode);		/* overall format */
 		pq_sendint(&buf, natts, 2);
+
+		if (!cstate->raw)
+			format = cstate->binary ? 1 : 0;
+		else
+			format = cstate->binary ? 3 : 2;
+
 		for (i = 0; i < natts; i++)
 			pq_sendint(&buf, format, 2);		/* per-column formats */
 		pq_endmessage(&buf);
@@ -402,10 +433,10 @@ ReceiveCopyBegin(CopyState cstate)
 	else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
 	{
 		/* old way */
-		if (cstate->binary)
+		if (cstate->binary || cstate->raw)
 			ereport(ERROR,
 					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-			errmsg("COPY BINARY is not supported to stdout or from stdin")));
+			errmsg("COPY BINARY or COPY RAW_TEXT/RAW_BINARY is not supported to stdout or from stdin")));
 		pq_putemptymessage('G');
 		/* any error in old protocol will make us lose sync */
 		pq_startmsgread();
@@ -414,10 +445,10 @@ ReceiveCopyBegin(CopyState cstate)
 	else
 	{
 		/* very old way */
-		if (cstate->binary)
+		if (cstate->binary || cstate->raw)
 			ereport(ERROR,
 					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-			errmsg("COPY BINARY is not supported to stdout or from stdin")));
+			errmsg("COPY BINARY or COPY RAW_TEXT/RAW_BINARY is not supported to stdout or from stdin")));
 		pq_putemptymessage('D');
 		/* any error in old protocol will make us lose sync */
 		pq_startmsgread();
@@ -482,7 +513,7 @@ CopySendEndOfRow(CopyState cstate)
 	switch (cstate->copy_dest)
 	{
 		case COPY_FILE:
-			if (!cstate->binary)
+			if (!cstate->binary && !cstate->raw)
 			{
 				/* Default line termination depends on platform */
 #ifndef WIN32
@@ -526,6 +557,9 @@ CopySendEndOfRow(CopyState cstate)
 			}
 			break;
 		case COPY_OLD_FE:
+			/* This old protocol doesn't allow RAW_TEXT/RAW_BINARY */
+			Assert(!cstate->raw);
+
 			/* The FE/BE protocol uses \n as newline for all platforms */
 			if (!cstate->binary)
 				CopySendChar(cstate, '\n');
@@ -540,7 +574,7 @@ CopySendEndOfRow(CopyState cstate)
 			break;
 		case COPY_NEW_FE:
 			/* The FE/BE protocol uses \n as newline for all platforms */
-			if (!cstate->binary)
+			if (!cstate->binary && !cstate->raw)
 				CopySendChar(cstate, '\n');
 
 			/* Dump the accumulated row as one CopyData message */
@@ -766,6 +800,38 @@ CopyLoadRawBuf(CopyState cstate)
 	return (inbytes > 0);
 }
 
+/*
+ * CopyLoadallRawBuf loads all content into raw_buf.
+ *
+ * This routine is used in raw_text/raw_binary mode. If original RAW_BUF_SIZE is not
+ * enough, then the buffer is enlarged.
+ */
+static void
+CopyLoadallRawBuf(CopyState cstate)
+{
+	int			nbytes = 0;
+	int			inbytes;
+	Size		raw_buf_size = RAW_BUF_SIZE;
+
+	do
+	{
+		/* hold enough space for one data packet */
+		if ((raw_buf_size - nbytes - 1) < 8 * 1024)
+		{
+			raw_buf_size += RAW_BUF_SIZE;
+			cstate->raw_buf = repalloc(cstate->raw_buf, raw_buf_size);
+		}
+
+		inbytes = CopyGetData(cstate, cstate->raw_buf + nbytes, 1, raw_buf_size - nbytes - 1);
+		nbytes += inbytes;
+	}
+	while (inbytes > 0);
+
+	cstate->raw_buf[nbytes] = '\0';
+	cstate->raw_buf_index = 0;
+	cstate->raw_buf_len = nbytes;
+}
+
 
 /*
  *	 DoCopy executes the SQL COPY statement
@@ -1013,6 +1079,13 @@ ProcessCopyOptions(CopyState cstate,
 				cstate->csv_mode = true;
 			else if (strcmp(fmt, "binary") == 0)
 				cstate->binary = true;
+			else if (strcmp(fmt, "raw_text") == 0)
+				cstate->raw = true;
+			else if (strcmp(fmt, "raw_binary") == 0)
+			{
+				cstate->binary = true;
+				cstate->raw = true;
+			}
 			else
 				ereport(ERROR,
 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
@@ -1162,16 +1235,21 @@ ProcessCopyOptions(CopyState cstate,
 	 * Check for incompatible options (must do these two before inserting
 	 * defaults)
 	 */
-	if (cstate->binary && cstate->delim)
+	if ((cstate->binary || cstate->raw)  && cstate->delim)
 		ereport(ERROR,
 				(errcode(ERRCODE_SYNTAX_ERROR),
 				 errmsg("cannot specify DELIMITER in BINARY mode")));
 
-	if (cstate->binary && cstate->null_print)
+	if ((cstate->binary || cstate->raw) && cstate->null_print)
 		ereport(ERROR,
 				(errcode(ERRCODE_SYNTAX_ERROR),
 				 errmsg("cannot specify NULL in BINARY mode")));
 
+	if (cstate->raw && cstate->oids)
+		ereport(ERROR,
+				(errcode(ERRCODE_SYNTAX_ERROR),
+				 errmsg("cannot specify OIDS in RAW_TEXT/RAW_BINARY mode")));
+
 	/* Set defaults for omitted options */
 	if (!cstate->delim)
 		cstate->delim = cstate->csv_mode ? "," : "\t";
@@ -1608,6 +1686,12 @@ BeginCopy(bool is_from,
 		}
 	}
 
+	/* No more columns are allowed in RAW mode */
+	if (cstate->raw && list_length(cstate->attnumlist) > 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+		 errmsg("Single column result/target is required in RAW_TEXT/RAW_BINARY mode")));
+
 	/* Use client encoding when ENCODING option is not specified. */
 	if (cstate->file_encoding < 0)
 		cstate->file_encoding = pg_get_client_encoding();
@@ -1899,7 +1983,7 @@ CopyTo(CopyState cstate)
 											   ALLOCSET_DEFAULT_INITSIZE,
 											   ALLOCSET_DEFAULT_MAXSIZE);
 
-	if (cstate->binary)
+	if (cstate->binary && !cstate->raw)
 	{
 		/* Generate header for a binary copy */
 		int32		tmp;
@@ -1931,6 +2015,9 @@ CopyTo(CopyState cstate)
 		{
 			bool		hdr_delim = false;
 
+			/* raw_text/raw_binary mode is not allowed here */
+			Assert(!cstate->raw);
+
 			foreach(cur, cstate->attnumlist)
 			{
 				int			attnum = lfirst_int(cur);
@@ -1967,6 +2054,10 @@ CopyTo(CopyState cstate)
 		{
 			CHECK_FOR_INTERRUPTS();
 
+			/* stop quickly in raw_text/raw_binary when more rows is detected */
+			if (cstate->raw && processed > 0)
+				break;
+
 			/* Deconstruct the tuple ... faster than repeated heap_getattr */
 			heap_deform_tuple(tuple, tupDesc, values, nulls);
 
@@ -1983,11 +2074,25 @@ CopyTo(CopyState cstate)
 	else
 	{
 		/* run the plan --- the dest receiver will send tuples */
-		ExecutorRun(cstate->queryDesc, ForwardScanDirection, 0L);
+		ExecutorRun(cstate->queryDesc, ForwardScanDirection, cstate->raw ? 2L : 0L);
 		processed = ((DR_copy *) cstate->queryDesc->dest)->processed;
 	}
 
-	if (cstate->binary)
+	/* raw_text/raw_binary requires exactly one row */
+	if (cstate->raw)
+	{
+		if (processed > 1)
+			ereport(ERROR,
+					(errcode(ERRCODE_TOO_MANY_ROWS),
+					 errmsg("single row result is required by RAW_TEXT/RAW_BINARY mode")));
+
+		if (processed == 0)
+			ereport(ERROR,
+					(errcode(ERRCODE_NO_DATA_FOUND),
+					 errmsg("single row result is required by RAW_TEXT/RAW_BINARY mode")));
+	}
+
+	if (cstate->binary && !cstate->raw)
 	{
 		/* Generate trailer for a binary copy */
 		CopySendInt16(cstate, -1);
@@ -2015,28 +2120,31 @@ CopyOneRowTo(CopyState cstate, Oid tupleOid, Datum *values, bool *nulls)
 	MemoryContextReset(cstate->rowcontext);
 	oldcontext = MemoryContextSwitchTo(cstate->rowcontext);
 
-	if (cstate->binary)
+	if (!cstate->raw)
 	{
-		/* Binary per-tuple header */
-		CopySendInt16(cstate, list_length(cstate->attnumlist));
-		/* Send OID if wanted --- note attnumlist doesn't include it */
-		if (cstate->oids)
+		if (cstate->binary)
 		{
-			/* Hack --- assume Oid is same size as int32 */
-			CopySendInt32(cstate, sizeof(int32));
-			CopySendInt32(cstate, tupleOid);
+			/* Binary per-tuple header */
+			CopySendInt16(cstate, list_length(cstate->attnumlist));
+			/* Send OID if wanted --- note attnumlist doesn't include it */
+			if (cstate->oids)
+			{
+				/* Hack --- assume Oid is same size as int32 */
+				CopySendInt32(cstate, sizeof(int32));
+				CopySendInt32(cstate, tupleOid);
+			}
 		}
-	}
-	else
-	{
-		/* Text format has no per-tuple header, but send OID if wanted */
-		/* Assume digits don't need any quoting or encoding conversion */
-		if (cstate->oids)
+		else
 		{
-			string = DatumGetCString(DirectFunctionCall1(oidout,
-												ObjectIdGetDatum(tupleOid)));
-			CopySendString(cstate, string);
-			need_delim = true;
+			/* Text format has no per-tuple header, but send OID if wanted */
+			/* Assume digits don't need any quoting or encoding conversion */
+			if (cstate->oids)
+			{
+				string = DatumGetCString(DirectFunctionCall1(oidout,
+													ObjectIdGetDatum(tupleOid)));
+				CopySendString(cstate, string);
+				need_delim = true;
+			}
 		}
 	}
 
@@ -2055,6 +2163,11 @@ CopyOneRowTo(CopyState cstate, Oid tupleOid, Datum *values, bool *nulls)
 
 		if (isnull)
 		{
+			if (cstate->raw)
+				ereport(ERROR,
+						(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+						 errmsg("NULL value is not allowed in RAW_TEXT/RAW_BINARY mode")));
+
 			if (!cstate->binary)
 				CopySendString(cstate, cstate->null_print_client);
 			else
@@ -2062,7 +2175,72 @@ CopyOneRowTo(CopyState cstate, Oid tupleOid, Datum *values, bool *nulls)
 		}
 		else
 		{
-			if (!cstate->binary)
+			if (cstate->raw)
+			{
+				const void *content;
+				int size;
+			
+				if (!cstate->binary)
+				{
+					string = OutputFunctionCall(&out_functions[attnum - 1],
+												value);
+
+					/* We would to transcode, but without escaping */
+					if (cstate->need_transcoding)
+						content = pg_server_to_any(string, strlen(string), cstate->file_encoding);
+					else
+						content = string;
+
+					size = strlen((const char *) content);
+				}
+				else
+				{
+					bytea *outputbytes;
+
+					/*
+					 * Some binary output functions depends can depends on client encoding.
+					 * The binary output of xml is good example. Set client_encoding
+					 * temporaly before out function execution.
+					 */
+					if (cstate->need_transcoding)
+					{
+						int		old_server_encoding = pg_get_client_encoding();
+						volatile bool reset_encoding = false;
+
+						PG_TRY();
+						{
+							/* We don't expect an error, because encoding was checked before */
+							if (PrepareClientEncoding(cstate->file_encoding) < 0)
+								elog(ERROR, "PrepareClientEncoding(%d) failed", cstate->file_encoding);
+
+							SetClientEncoding(cstate->file_encoding);
+							reset_encoding = true;
+
+							outputbytes = SendFunctionCall(&out_functions[attnum - 1],
+													   value);
+							SetClientEncoding(old_server_encoding);
+						}
+						PG_CATCH();
+						{
+							if (reset_encoding)
+								SetClientEncoding(old_server_encoding);
+							PG_RE_THROW();
+						}
+						PG_END_TRY();
+					}
+					else
+					{
+						outputbytes = SendFunctionCall(&out_functions[attnum - 1],
+												   value);
+					}
+					content = VARDATA(outputbytes);
+					size = VARSIZE(outputbytes) - VARHDRSZ;
+				}
+
+				/* Send only content in RAW_TEXT/RAW_BINARY mode */
+				CopySendData(cstate, content, size);
+			}
+			else if (!cstate->binary)
 			{
 				string = OutputFunctionCall(&out_functions[attnum - 1],
 											value);
@@ -2811,65 +2989,69 @@ BeginCopyFrom(Relation rel,
 		}
 	}
 
-	if (!cstate->binary)
+	/* The raw mode hasn't any header information */
+	if (!cstate->raw)
 	{
-		/* must rely on user to tell us... */
-		cstate->file_has_oids = cstate->oids;
-	}
-	else
-	{
-		/* Read and verify binary header */
-		char		readSig[11];
-		int32		tmp;
-
-		/* Signature */
-		if (CopyGetData(cstate, readSig, 11, 11) != 11 ||
-			memcmp(readSig, BinarySignature, 11) != 0)
-			ereport(ERROR,
-					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
-					 errmsg("COPY file signature not recognized")));
-		/* Flags field */
-		if (!CopyGetInt32(cstate, &tmp))
-			ereport(ERROR,
-					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
-					 errmsg("invalid COPY file header (missing flags)")));
-		cstate->file_has_oids = (tmp & (1 << 16)) != 0;
-		tmp &= ~(1 << 16);
-		if ((tmp >> 16) != 0)
-			ereport(ERROR,
-					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
-				 errmsg("unrecognized critical flags in COPY file header")));
-		/* Header extension length */
-		if (!CopyGetInt32(cstate, &tmp) ||
-			tmp < 0)
-			ereport(ERROR,
-					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
-					 errmsg("invalid COPY file header (missing length)")));
-		/* Skip extension header, if present */
-		while (tmp-- > 0)
+		if (!cstate->binary)
+		{
+			/* must rely on user to tell us... */
+			cstate->file_has_oids = cstate->oids;
+		}
+		else
 		{
-			if (CopyGetData(cstate, readSig, 1, 1) != 1)
+			/* Read and verify binary header */
+			char		readSig[11];
+			int32		tmp;
+
+			/* Signature */
+			if (CopyGetData(cstate, readSig, 11, 11) != 11 ||
+				memcmp(readSig, BinarySignature, 11) != 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
+						 errmsg("COPY file signature not recognized")));
+			/* Flags field */
+			if (!CopyGetInt32(cstate, &tmp))
 				ereport(ERROR,
 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
-						 errmsg("invalid COPY file header (wrong length)")));
+						 errmsg("invalid COPY file header (missing flags)")));
+			cstate->file_has_oids = (tmp & (1 << 16)) != 0;
+			tmp &= ~(1 << 16);
+			if ((tmp >> 16) != 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
+					 errmsg("unrecognized critical flags in COPY file header")));
+			/* Header extension length */
+			if (!CopyGetInt32(cstate, &tmp) ||
+				tmp < 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
+						 errmsg("invalid COPY file header (missing length)")));
+			/* Skip extension header, if present */
+			while (tmp-- > 0)
+			{
+				if (CopyGetData(cstate, readSig, 1, 1) != 1)
+					ereport(ERROR,
+							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
+							 errmsg("invalid COPY file header (wrong length)")));
+			}
 		}
-	}
 
-	if (cstate->file_has_oids && cstate->binary)
-	{
-		getTypeBinaryInputInfo(OIDOID,
-							   &in_func_oid, &cstate->oid_typioparam);
-		fmgr_info(in_func_oid, &cstate->oid_in_function);
-	}
+		if (cstate->file_has_oids && cstate->binary)
+		{
+			getTypeBinaryInputInfo(OIDOID,
+								   &in_func_oid, &cstate->oid_typioparam);
+			fmgr_info(in_func_oid, &cstate->oid_in_function);
+		}
 
-	/* create workspace for CopyReadAttributes results */
-	if (!cstate->binary)
-	{
-		AttrNumber	attr_count = list_length(cstate->attnumlist);
-		int			nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
+		/* create workspace for CopyReadAttributes results */
+		if (!cstate->binary)
+		{
+			AttrNumber	attr_count = list_length(cstate->attnumlist);
+			int			nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
 
-		cstate->max_fields = nfields;
-		cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
+			cstate->max_fields = nfields;
+			cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
+		}
 	}
 
 	MemoryContextSwitchTo(oldcontext);
@@ -2968,7 +3150,54 @@ NextCopyFrom(CopyState cstate, ExprContext *econtext,
 	MemSet(values, 0, num_phys_attrs * sizeof(Datum));
 	MemSet(nulls, true, num_phys_attrs * sizeof(bool));
 
-	if (!cstate->binary)
+	if (cstate->raw)
+	{
+		int		m = linitial_int(cstate->attnumlist) - 1;
+
+		/* All content was read in first cycle */
+		if (++cstate->cur_lineno > 1)
+			return false;
+
+		CopyLoadallRawBuf(cstate);
+
+		cstate->cur_attname = NameStr(attr[m]->attname);
+
+		if (!cstate->binary)
+		{
+			char	   *cvt;
+
+			cvt = pg_any_to_server(cstate->raw_buf,
+								   cstate->raw_buf_len,
+								   cstate->file_encoding);
+
+			values[m] = InputFunctionCall(&in_functions[m],
+										  cvt,
+										  typioparams[m],
+										  attr[m]->atttypmod);
+		}
+		else
+		{
+			cstate->attribute_buf.data = cstate->raw_buf;
+			cstate->attribute_buf.len = cstate->raw_buf_len;
+			cstate->attribute_buf.cursor = 0;
+			cstate->raw_buf = NULL;
+
+			/* Call the column type's binary input converter */
+			values[m] = ReceiveFunctionCall(&in_functions[m], &cstate->attribute_buf,
+									 typioparams[m], attr[m]->atttypmod);
+
+			/* Trouble if it didn't eat the whole buffer */
+			if (cstate->attribute_buf.cursor != cstate->attribute_buf.len)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
+						 errmsg("incorrect binary data format")));
+		}
+
+		nulls[m] = false;
+
+		cstate->cur_attname = NULL;
+	}
+	else if (!cstate->binary)
 	{
 		char	  **field_strings;
 		ListCell   *cur;
diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c
index 8469d9f..2c8d6f5 100644
--- a/src/bin/psql/tab-complete.c
+++ b/src/bin/psql/tab-complete.c
@@ -1974,8 +1974,8 @@ psql_completion(const char *text, int start, int end)
 	/* Handle COPY [BINARY] <sth> FROM|TO filename */
 	else if (Matches4("COPY|\\copy", MatchAny, "FROM|TO", MatchAny) ||
 			 Matches5("COPY", "BINARY", MatchAny, "FROM|TO", MatchAny))
-		COMPLETE_WITH_LIST6("BINARY", "OIDS", "DELIMITER", "NULL", "CSV",
-							"ENCODING");
+		COMPLETE_WITH_LIST8("BINARY", "RAW_TEXT", "RAW_BINARY", "OIDS",
+							"DELIMITER", "NULL", "CSV", "ENCODING");
 
 	/* Handle COPY [BINARY] <sth> FROM|TO filename CSV */
 	else if (Matches5("COPY|\\copy", MatchAny, "FROM|TO", MatchAny, "CSV") ||
diff --git a/src/interfaces/libpq/exports.txt b/src/interfaces/libpq/exports.txt
index 21dd772..a2754f1 100644
--- a/src/interfaces/libpq/exports.txt
+++ b/src/interfaces/libpq/exports.txt
@@ -171,3 +171,4 @@ PQsslAttributeNames       168
 PQsslAttribute            169
 PQsetErrorContextVisibility 170
 PQresultVerboseErrorMessage 171
+PQcopyFormat              172
diff --git a/src/interfaces/libpq/fe-exec.c b/src/interfaces/libpq/fe-exec.c
index 2621767..09967e9 100644
--- a/src/interfaces/libpq/fe-exec.c
+++ b/src/interfaces/libpq/fe-exec.c
@@ -155,6 +155,7 @@ PQmakeEmptyPGresult(PGconn *conn, ExecStatusType status)
 	result->resultStatus = status;
 	result->cmdStatus[0] = '\0';
 	result->binary = 0;
+	result->raw = 0;
 	result->events = NULL;
 	result->nEvents = 0;
 	result->errMsg = NULL;
@@ -256,8 +257,10 @@ PQsetResultAttrs(PGresult *res, int numAttributes, PGresAttDesc *attDescs)
 		if (!res->attDescs[i].name)
 			return FALSE;
 
-		if (res->attDescs[i].format == 0)
+		if (res->attDescs[i].format == 0 || res->attDescs[i].format == 2)
 			res->binary = 0;
+		if (res->attDescs[i].format == 2 || res->attDescs[i].format == 3)
+			res->raw = 1;
 	}
 
 	return TRUE;
@@ -2932,6 +2935,21 @@ PQcmdStatus(PGresult *res)
 }
 
 /*
+ * PQcopyFormat
+ *
+ * Returns a info about copy mode:
+ * -1 signalize a error, 0 = text mode, 1 = binary mode, 2 = raw mode
+ */
+int
+PQcopyFormat(const PGresult *res)
+{
+	if (res->raw)
+		return 2;
+	else
+		return res->binary;
+}
+
+/*
  * PQoidStatus -
  *	if the last command was an INSERT, return the oid string
  *	if not, return ""
diff --git a/src/interfaces/libpq/fe-protocol3.c b/src/interfaces/libpq/fe-protocol3.c
index 0b8c62f..1783844 100644
--- a/src/interfaces/libpq/fe-protocol3.c
+++ b/src/interfaces/libpq/fe-protocol3.c
@@ -1486,6 +1486,10 @@ getCopyStart(PGconn *conn, ExecStatusType copytype)
 		 */
 		format = (int) ((int16) format);
 		result->attDescs[i].format = format;
+
+		/* when any field uses raw format, then COPY RAW_* was used */
+		if (format == 2 || format == 3)
+			result->raw = true;
 	}
 
 	/* Success! */
diff --git a/src/interfaces/libpq/libpq-fe.h b/src/interfaces/libpq/libpq-fe.h
index 9ca0756..7984666 100644
--- a/src/interfaces/libpq/libpq-fe.h
+++ b/src/interfaces/libpq/libpq-fe.h
@@ -479,6 +479,7 @@ extern Oid	PQftype(const PGresult *res, int field_num);
 extern int	PQfsize(const PGresult *res, int field_num);
 extern int	PQfmod(const PGresult *res, int field_num);
 extern char *PQcmdStatus(PGresult *res);
+extern int	PQcopyFormat(const PGresult *res);
 extern char *PQoidStatus(const PGresult *res);	/* old and ugly */
 extern Oid	PQoidValue(const PGresult *res);	/* new and improved */
 extern char *PQcmdTuples(PGresult *res);
diff --git a/src/interfaces/libpq/libpq-int.h b/src/interfaces/libpq/libpq-int.h
index 1183323..8fc4b04 100644
--- a/src/interfaces/libpq/libpq-int.h
+++ b/src/interfaces/libpq/libpq-int.h
@@ -180,6 +180,7 @@ struct pg_result
 	char		cmdStatus[CMDSTATUS_LEN];		/* cmd status from the query */
 	int			binary;			/* binary tuple values if binary == 1,
 								 * otherwise text */
+	int			raw;			/* raw mode for COPY */
 
 	/*
 	 * These fields are copied from the originating PGconn, so that operations
diff --git a/src/interfaces/libpq/test/Makefile b/src/interfaces/libpq/test/Makefile
index ab41dc3..f5f1511 100644
--- a/src/interfaces/libpq/test/Makefile
+++ b/src/interfaces/libpq/test/Makefile
@@ -9,14 +9,18 @@ endif
 override CPPFLAGS := -I$(libpq_srcdir) $(CPPFLAGS)
 override LDLIBS := $(libpq_pgport) $(LDLIBS)
 
-PROGS = uri-regress
+PROGS = uri-regress copy-raw-regress
 
 all: $(PROGS)
 
 installcheck: all
 	SRCDIR='$(top_srcdir)' SUBDIR='$(subdir)' \
 		   $(PERL) $(top_srcdir)/$(subdir)/regress.pl
+	SRCDIR='$(top_srcdir)' SUBDIR='$(subdir)' \
+		   $(PERL) $(top_srcdir)/$(subdir)/copy-raw-regress.pl
 
 clean distclean maintainer-clean:
 	rm -f $(PROGS)
 	rm -f regress.out regress.diff
+	rm -f copy-raw-regress.out
+	rm -f uri-regress.o copy-raw-regress.o
\ No newline at end of file
diff --git a/src/interfaces/libpq/test/copy-raw-expected.out b/src/interfaces/libpq/test/copy-raw-expected.out
new file mode 100644
index 0000000..6bbef51
--- /dev/null
+++ b/src/interfaces/libpq/test/copy-raw-expected.out
@@ -0,0 +1,33 @@
+trying
+copy-raw-regress: buffer is empty
+copy-raw-regress: the test COPY TO was successful (a, raw_text, 0)
+copy-raw-regress: buffer is empty
+copy-raw-regress: the test COPY TO was successful (b, raw_binary, 0)
+copy-raw-regress: the test COPY TO was successful (a, raw_text, 1)
+copy-raw-regress: the test COPY TO was successful (b, raw_binary, 1)
+copy-raw-regress: the test COPY TO was successful (a, raw_text, 10)
+copy-raw-regress: the test COPY TO was successful (b, raw_binary, 10)
+copy-raw-regress: the test COPY TO was successful (a, raw_text, 1000)
+copy-raw-regress: the test COPY TO was successful (b, raw_binary, 1000)
+copy-raw-regress: the test COPY TO was successful (a, raw_text, 10000)
+copy-raw-regress: the test COPY TO was successful (b, raw_binary, 10000)
+copy-raw-regress: the test COPY TO was successful (a, raw_text, 100000)
+copy-raw-regress: the test COPY TO was successful (b, raw_binary, 100000)
+copy-raw-regress: the test COPY TO was successful (a, raw_text, 1000000)
+copy-raw-regress: the test COPY TO was successful (b, raw_binary, 1000000)
+copy-raw-regress: the test COPY FROM was successful (a, raw_text, 0)
+copy-raw-regress: the test COPY FROM was successful (b, raw_binary, 0)
+copy-raw-regress: the test COPY FROM was successful (a, raw_text, 1)
+copy-raw-regress: the test COPY FROM was successful (b, raw_binary, 1)
+copy-raw-regress: the test COPY FROM was successful (a, raw_text, 10)
+copy-raw-regress: the test COPY FROM was successful (b, raw_binary, 10)
+copy-raw-regress: the test COPY FROM was successful (a, raw_text, 1000)
+copy-raw-regress: the test COPY FROM was successful (b, raw_binary, 1000)
+copy-raw-regress: the test COPY FROM was successful (a, raw_text, 10000)
+copy-raw-regress: the test COPY FROM was successful (b, raw_binary, 10000)
+copy-raw-regress: the test COPY FROM was successful (a, raw_text, 100000)
+copy-raw-regress: the test COPY FROM was successful (b, raw_binary, 100000)
+copy-raw-regress: the test COPY FROM was successful (a, raw_text, 1000000)
+copy-raw-regress: the test COPY FROM was successful (b, raw_binary, 1000000)
+COPY RAW tests done
+
diff --git a/src/interfaces/libpq/test/copy-raw-regress.c b/src/interfaces/libpq/test/copy-raw-regress.c
new file mode 100644
index 0000000..2cdb331
--- /dev/null
+++ b/src/interfaces/libpq/test/copy-raw-regress.c
@@ -0,0 +1,597 @@
+/*
+ * copy-raw-regress.c
+ *		A test program for COPY API
+ *
+ * Portions Copyright (c) 2012-2016, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *		src/interfaces/libpq/test/copy-raw-regress.c
+ */
+
+#include "postgres_fe.h"
+
+#include "libpq-fe.h"
+#include "pqexpbuffer.h"
+#include "catalog/pg_type.h"
+
+char *text_message = "The PostgreSQL Database, ";
+char *binary_message = "\360\237\230\203\040\360\237\230\202\040";
+
+const char *prgname = "copy-raw-regress";
+
+/*
+ * Hide possible notice from DROP TABLE IF EXIT statement
+ *
+ */
+static void
+terseNoticeProcessor(void *arg, const char *message)
+{
+	/* do nothing */
+}
+
+/*
+ * Prepare textual and binary data with requested size.
+ *
+ */
+static void
+PrepareTestValues(char *values[], int size)
+{
+	char	*tbuffer;
+	char	*bbuffer;
+	char		*p;
+	int			 nchars;
+	int			 l;
+
+	tbuffer = pg_malloc(size + 1);
+	bbuffer = pg_malloc(size + 1);
+
+	p = tbuffer;
+	nchars = size;
+	l = strlen(text_message);
+	while (nchars > 0)
+	{
+		if (l < nchars)
+		{
+			strcpy(p, text_message);
+			p += l;
+			nchars -= l;
+		}
+		else
+		{
+			strncpy(p, text_message, nchars);
+			nchars = 0;
+		}
+	}
+
+	tbuffer[size] = '\0';
+	values[0] = tbuffer;
+
+	p = bbuffer;
+	nchars = size;
+	l = 10;
+	while (nchars > 0)
+	{
+		if (l < nchars)
+		{
+			memcpy(p, binary_message, l);
+			p += l;
+			nchars -= l;
+		}
+		else
+		{
+			memset(p, 0, nchars);
+			nchars = 0;
+		}
+	}
+
+	bbuffer[size] = '\0';
+	values[1] = bbuffer;
+}
+
+/*
+ * Store textual and binary data in table copy_raw. Clean this table before.
+ *
+ */
+static bool
+InsertData(PGconn *conn, char *values[], int size)
+{
+	PGresult	*res;
+	Oid		 types[] = {TEXTOID, BYTEAOID};
+	int		 formats[] = {0, 1};
+	int		 lens[2];
+
+	lens[0] = 0;						/* text format is used, value is ignored */
+	lens[1] = size;						/* binary mode, value should be correct */
+
+	res = PQexec(conn, "TRUNCATE TABLE copy_raw");
+	if (PQresultStatus(res) != PGRES_COMMAND_OK)
+	{
+		fprintf(stderr, "%s: could not to truncate table \"copy_raw\": %s",
+				  prgname, PQerrorMessage(conn));
+		PQclear(res);
+		return false;
+	}
+	PQclear(res);
+
+	res = PQexecParams(conn, "INSERT INTO copy_raw(id, a,b) VALUES(1, $1, $2)",
+							 2,
+							 types,
+							 (const char * const*) values,
+							 lens,
+							 formats,
+							 0);
+	if (PQresultStatus(res) != PGRES_COMMAND_OK)
+	{
+		fprintf(stderr, "%s: could not to insert to table \"copy_raw\": %s\n",
+				  prgname, PQerrorMessage(conn));
+		PQclear(res);
+		return false;
+	}
+	PQclear(res);
+	return true;
+}
+
+/*
+ * COPY TO test - insert data to server, get it with COPY API and compare result
+ *
+ */
+static bool
+CopyToTest(PGconn *conn, int colnum, const char *method, int size)
+{
+	char 	*colnames[] = {"a", "b"};
+	char	*values[2];
+	PGresult	*res;
+	PQExpBufferData		 query;
+	int					 len;
+	char				*buffer;
+
+	PrepareTestValues(values, size);
+	if (!InsertData(conn, values, size))
+		return false;
+
+	initPQExpBuffer(&query);
+	appendPQExpBuffer(&query,
+					  "COPY (SELECT %s FROM copy_raw WHERE id = 1) TO stdout (FORMAT %s)",
+					  colnames[colnum],
+					  method);
+
+	res = PQexec(conn, query.data);
+	if (PQresultStatus(res) != PGRES_COPY_OUT)
+	{
+		fprintf(stderr, "%s: could not to execute \"%s\": %s\n",
+				  prgname,
+				  query.data,
+				  PQerrorMessage(conn));
+		PQclear(res);
+		return false;
+	}
+
+	PQclear(res);
+
+	len = PQgetCopyData(conn, &buffer, false);
+	if (len == -2)
+	{
+		fprintf(stderr, "%s: cannot to get data: %s\n",
+				  prgname, PQerrorMessage(conn));
+		return false;
+	}
+
+	if (len == -1)
+	{
+		fprintf(stderr, "%s: buffer is empty\n",
+				  prgname);
+
+		res = PQgetResult(conn);
+		if (PQresultStatus(res) != PGRES_COMMAND_OK)
+		{
+			fprintf(stderr, "%s: could not to execute \"%s\": %s\n",
+					  prgname,
+					  query.data,
+					  PQerrorMessage(conn));
+			PQclear(res);
+			return false;
+		}
+		PQclear(res);
+
+		len = 0;
+	}
+
+	if (len != size)
+	{
+		fprintf(stderr, "%s: the length of data (%d) is different than expected (%d)\n",
+				prgname, len, size);
+		return false;
+	}
+
+	if (len > 0 && memcmp(values[colnum], buffer, len) != 0)
+	{
+		fprintf(stderr, "%s: the content of loaded data is different than expected\n",
+				  prgname);
+		return false;
+	}
+
+	fprintf(stderr, "%s: the test COPY TO was successful (%s, %s, %d)\n",
+				prgname,
+				colnames[colnum],
+				method,
+				size);
+
+	PQfreemem(buffer);
+	termPQExpBuffer(&query);
+
+	pg_free(values[0]);
+	pg_free(values[1]);
+
+	return true;
+}
+
+static PGconn *
+PrepareConnection(char *connectionstr)
+{
+	PQconninfoOption *opts;
+	PQconninfoOption *opt;
+	char	   *errmsg = NULL;
+	const char **keywords = NULL;
+	const char **values = NULL;
+	int		nopts = 0;
+	int		i = 0;
+	PGconn		*conn;
+
+	opts = PQconninfoParse(connectionstr, &errmsg);
+	if (opts == NULL)
+	{
+		fprintf(stderr, "%s: %s\n", prgname, errmsg);
+		return NULL;
+	}
+
+	for (opt = opts; opt->keyword != NULL; opt++)
+	{
+		if (opt->val != NULL && opt->val[0] != '\0')
+			nopts++;
+	}
+
+	keywords = pg_malloc0((nopts + 1) * sizeof(*keywords));
+	values = pg_malloc0((nopts + 1) * sizeof(*values));
+
+	for (opt = opts; opt->keyword != NULL; opt++)
+	{
+		if (opt->val != NULL && opt->val[0] != '\0')
+		{
+			keywords[i] = opt->keyword;
+			values[i] = opt->val;
+			i++;
+		}
+	}
+
+	conn = PQconnectdbParams(keywords, values, false);
+	if (!conn)
+	{
+		fprintf(stderr, "%s: could not connect to server\n",
+				  prgname);
+		return NULL;
+	}
+
+	if (PQstatus(conn) != CONNECTION_OK)
+	{
+		fprintf(stderr, "%s: could not connect to server: %s",
+					prgname, PQerrorMessage(conn));
+		PQfinish(conn);
+		return NULL;
+	}
+
+	pg_free(values);
+	pg_free(keywords);
+	PQconninfoFree(opts);
+
+	return conn;
+}
+
+static bool
+CreateTable(PGconn *conn)
+{
+	PGresult *res;
+	PQnoticeProcessor prev_notproc;
+
+	prev_notproc = PQsetNoticeProcessor(conn, terseNoticeProcessor, NULL);
+
+	res = PQexec(conn, "DROP TABLE IF EXISTS copy_raw");
+	if (PQresultStatus(res) != PGRES_COMMAND_OK)
+	{
+		fprintf(stderr, "%s: could not drop table \"copy_raw\": %s",
+				  prgname, PQerrorMessage(conn));
+		PQclear(res);
+		return false;
+	}
+	PQclear(res);
+
+	PQsetNoticeProcessor(conn, prev_notproc, NULL);
+
+	res = PQexec(conn, "CREATE TABLE copy_raw(id serial, a text, b bytea)");
+	if (PQresultStatus(res) != PGRES_COMMAND_OK)
+	{
+		fprintf(stderr, "%s: could not create table table \"copy_raw\": %s",
+				  prgname, PQerrorMessage(conn));
+		PQclear(res);
+		return false;
+	}
+	PQclear(res);
+
+	return true;
+}
+
+static bool
+DropTable(PGconn *conn)
+{
+	PGresult *res;
+
+	res = PQexec(conn, "DROP TABLE copy_raw");
+	if (PQresultStatus(res) != PGRES_COMMAND_OK)
+	{
+		fprintf(stderr, "%s: could not drop table \"copy_raw\": %s",
+				  prgname, PQerrorMessage(conn));
+		PQclear(res);
+		return false;
+	}
+	PQclear(res);
+
+	return true;
+}
+
+/*
+ * returns result of lastval()
+ *
+ *  returns false on error
+ */
+static bool
+get_lastval(PGconn *conn, int *lastval)
+{
+	PGresult *res;
+	char		*val;
+
+	res = PQexec(conn, "SELECT lastval()");
+	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+	{
+		fprintf(stderr, "%s: could not to call lastval function: %s",
+				  prgname, PQerrorMessage(conn));
+		PQclear(res);
+		return false;
+	}
+
+	val = PQgetvalue(res, 0, 0);
+	Assert(val != NULL);
+
+	*lastval = atoi(val);
+
+	PQclear(res);
+
+	return true;
+}
+
+
+/*
+ * does COPY FROM RAW
+ *
+ */
+static bool
+DoCopyFromBuffer(PGconn *conn, int colnum, const char *method, const char *buffer, int size, int *id)
+{
+	PQExpBufferData		 query;
+	PGresult			*res;
+	char 	*colnames[] = {"a", "b"};
+	int		copy_data_res;
+	const char		*errormsg = NULL;
+
+	res = PQexec(conn, "TRUNCATE TABLE copy_raw");
+	if (PQresultStatus(res) != PGRES_COMMAND_OK)
+	{
+		fprintf(stderr, "%s: could not to truncate table \"copy_raw\": %s",
+				  prgname, PQerrorMessage(conn));
+		PQclear(res);
+		return false;
+	}
+	PQclear(res);
+
+	initPQExpBuffer(&query);
+	appendPQExpBuffer(&query,
+					  "COPY copy_raw(%s) FROM stdin (FORMAT %s)",
+					  colnames[colnum],
+					  method);
+
+	res = PQexec(conn, query.data);
+
+
+	if (PQresultStatus(res) != PGRES_COPY_IN)
+	{
+		fprintf(stderr, "%s: could not to execute \"%s\": %s\n",
+				  prgname,
+				  query.data,
+				  PQerrorMessage(conn));
+		PQclear(res);
+		return false;
+	}
+
+	PQclear(res);
+
+	copy_data_res = PQputCopyData(conn, buffer, size);
+	if (copy_data_res == -1)
+	{
+		fprintf(stderr, "%s: could not to send data: %s\n",
+				  prgname, PQerrorMessage(conn));
+		return false;
+	}
+
+	copy_data_res = PQputCopyEnd(conn, errormsg);
+	if (errormsg != NULL)
+	{
+		fprintf(stderr, "%s: could not to send data: %s\n",
+				  prgname, errormsg);
+		return false;
+	}
+	if (copy_data_res == -1)
+	{
+		fprintf(stderr, "%s: could not to send data: %s\n",
+				  prgname, PQerrorMessage(conn));
+		return false;
+	}
+
+	res = PQgetResult(conn);
+	if (PQresultStatus(res) != PGRES_COMMAND_OK)
+	{
+		fprintf(stderr, "%s: could not to execute \"%s\": %s\n",
+				  prgname,
+				  query.data,
+				  PQerrorMessage(conn));
+		PQclear(res);
+		return false;
+	}
+
+	PQclear(res);
+	termPQExpBuffer(&query);
+
+	if (!get_lastval(conn, id))
+		return false;
+
+	return true;
+}
+
+/*
+ * Send data to server with COPY TO RAW, then get data back with SELECT BINARY
+ * and compare data.
+ */
+static bool
+CopyFromTest(PGconn *conn, int colnum, const char *method, int size)
+{
+	char 	*colnames[] = {"a", "b"};
+	char	*values[2];
+	PGresult	*res;
+	int			 id;
+	PQExpBufferData		 query;
+	char				*buffer;
+	int					len;
+
+	PrepareTestValues(values, size);
+
+	if (!DoCopyFromBuffer(conn, colnum, method, (const char *) values[colnum], size, &id))
+		return false;
+
+	initPQExpBuffer(&query);
+	appendPQExpBuffer(&query,
+					  "SELECT %s FROM copy_raw WHERE id = %d",
+					  colnames[colnum],
+					  id);
+
+	res = PQexecParams(conn, query.data,
+							 0,
+							 NULL,
+							 NULL,
+							 NULL,
+							 NULL,
+							 1);
+
+	if (PQresultStatus(res) != PGRES_TUPLES_OK)
+	{
+		fprintf(stderr, "%s: could not to execute \"%s\": %s\n",
+				  prgname,
+				  query.data,
+				  PQerrorMessage(conn));
+		PQclear(res);
+		return false;
+	}
+
+	termPQExpBuffer(&query);
+
+	buffer = PQgetvalue(res, 0, 0);
+	len = PQgetlength(res, 0, 0);
+
+	if (len != size)
+	{
+		fprintf(stderr, "%s: the length of data (%d) is different than expected (%d)\n",
+				prgname, len, size);
+		PQclear(res);
+		return false;
+	}
+
+	if (len > 0 && memcmp(values[colnum], buffer, len) != 0)
+	{
+		fprintf(stderr, "%s: the content of stored data is different than expected\n",
+				  prgname);
+		PQclear(res);
+		return false;
+	}
+
+	PQclear(res);
+
+	pg_free(values[0]);
+	pg_free(values[1]);
+
+	fprintf(stderr, "%s: the test COPY FROM was successful (%s, %s, %d)\n",
+				prgname,
+				colnames[colnum],
+				method,
+				size);
+
+	return true;
+}
+
+int
+main(int argc, char *argv[])
+{
+	PGconn *conn;
+	int		sizes[] = {0, 1, 10, 1000, 10000, 100000, 1000000};
+	const char *method[] = {"raw_text", "raw_binary"};
+	int		i;
+	int			j;
+
+	if (argc != 2)
+	{
+		fprintf(stderr, "%s: usage %s connection string\n",
+			  prgname, prgname);
+		exit(1);
+	}
+
+	conn = PrepareConnection(argv[1]);
+	if (conn == NULL)
+		exit(1);
+
+	if (!CreateTable(conn))
+	{
+		PQfinish(conn);
+		exit(1);
+	}
+
+	for (i = 0; i < 7; i++)
+	{
+		for (j = 0; j < 2; j++)
+		{
+			if (!CopyToTest(conn, j, method[j], sizes[i]))
+			{
+				PQfinish(conn);
+				exit(1);
+			}
+		}
+	}
+
+	for (i = 0; i < 7; i++)
+	{
+		for (j = 0; j < 2; j++)
+		{
+			if (!CopyFromTest(conn, j, method[j], sizes[i]))
+			{
+				PQfinish(conn);
+				exit(1);
+			}
+		}
+	}
+
+	if (!DropTable(conn))
+	{
+		PQfinish(conn);
+		exit(1);
+	}
+
+	PQfinish(conn);
+
+	fprintf(stderr, "COPY RAW tests done\n");
+
+	exit(0);
+}
diff --git a/src/interfaces/libpq/test/copy-raw-regress.pl b/src/interfaces/libpq/test/copy-raw-regress.pl
new file mode 100644
index 0000000..7b1714a
--- /dev/null
+++ b/src/interfaces/libpq/test/copy-raw-regress.pl
@@ -0,0 +1,48 @@
+#!/usr/bin/perl -w
+
+use strict;
+
+# use of SRCDIR/SUBDIR is required for supporting VPath builds
+my $srcdir = $ENV{'SRCDIR'} or die 'SRCDIR environment variable is not set';
+my $subdir = $ENV{'SUBDIR'} or die 'SUBDIR environment variable is not set';
+
+my $expected_out = "$srcdir/$subdir/copy-raw-expected.out";
+
+# the output file should land in the build_dir of VPath, or just in
+# the current dir, if VPath isn't used
+my $regress_out = "copy-raw-regress.out";
+
+# save STDOUT/ERR and redirect both to regress.out
+open(OLDOUT, ">&", \*STDOUT) or die "can't dup STDOUT: $!";
+open(OLDERR, ">&", \*STDERR) or die "can't dup STDERR: $!";
+
+open(STDOUT, ">", $regress_out)
+  or die "can't open $regress_out for writing: $!";
+open(STDERR, ">&", \*STDOUT) or die "can't dup STDOUT: $!";
+
+print "trying\n";
+system("./copy-raw-regress \"postgresql://\"");
+print "\n";
+
+# restore STDOUT/ERR so we can print the outcome to the user
+open(STDERR, ">&", \*OLDERR) or die; # can't complain as STDERR is still duped
+open(STDOUT, ">&", \*OLDOUT) or die "can't restore STDOUT: $!";
+
+my $diff_status = system(
+	"diff -c \"$srcdir/$subdir/$regress_out\" $expected_out >regress.diff");
+
+print "=" x 70, "\n";
+if ($diff_status == 0)
+{
+	print "All tests passed\n";
+	exit 0;
+}
+else
+{
+	print <<EOF;
+FAILED: the test result differs from the expected output
+
+Review the difference in "$subdir/regress.diff"
+EOF
+	exit 1;
+}
diff --git a/src/test/regress/expected/copy2.out b/src/test/regress/expected/copy2.out
index 5f6260a..3d36dd3 100644
--- a/src/test/regress/expected/copy2.out
+++ b/src/test/regress/expected/copy2.out
@@ -466,3 +466,17 @@ DROP FUNCTION truncate_in_subxact();
 DROP TABLE x, y;
 DROP FUNCTION fn_x_before();
 DROP FUNCTION fn_x_after();
+CREATE TABLE x(a bytea);
+INSERT INTO x VALUES('\x41484f4a0a');
+INSERT INTO x VALUES('\x41484f4a0a');
+-- should to fail
+COPY (SELECT a,a FROM x LIMIT 1) TO STDOUT (FORMAT raw_binary);
+ERROR:  Single column result/target is required in RAW_TEXT/RAW_BINARY mode
+COPY (SELECT a FROM x) TO STDOUT (FORMAT raw_binary);
+AHOJ
+AHOJ
+ERROR:  single row result is required by RAW_TEXT/RAW_BINARY mode
+-- should be ok
+COPY (SELECT a FROM x LIMIT 1) TO STDOUT (FORMAT raw_binary);
+AHOJ
+DROP TABLE x;
diff --git a/src/test/regress/input/copy.source b/src/test/regress/input/copy.source
index cb13606..085ae36 100644
--- a/src/test/regress/input/copy.source
+++ b/src/test/regress/input/copy.source
@@ -133,3 +133,82 @@ this is just a line full of junk that would error out if parsed
 \.
 
 copy copytest3 to stdout csv header;
+
+-- copy raw
+CREATE TABLE x(a bytea);
+INSERT INTO x VALUES('\x41484f4a0a');
+SELECT length(a) FROM x;
+
+INSERT INTO x VALUES('\x41484f4a0a');
+
+-- should to fail
+COPY (SELECT a,a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+COPY (SELECT a FROM x) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+
+-- should be ok
+COPY (SELECT a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+TRUNCATE x;
+COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+SELECT length(a) FROM x;
+COPY x TO stdout (FORMAT raw_binary);
+
+TRUNCATE x;
+
+\COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw_binary)
+SELECT length(a) FROM x;
+COPY x TO stdout (FORMAT raw_binary);
+
+\COPY x TO '@abs_builddir@/results/raw2.data' (FORMAT raw_binary)
+TRUNCATE x;
+
+\COPY x FROM '@abs_builddir@/results/raw2.data' (FORMAT raw_binary)
+SELECT length(a) FROM x;
+COPY x TO stdout (FORMAT raw_binary);
+
+-- test big file
+TRUNCATE x;
+-- use different mechanism for load to bytea
+\lo_import @abs_builddir@/data/hash.data
+\set lo_oid :LASTOID
+INSERT INTO x VALUES(lo_get(:lo_oid));
+\lo_unlink :lo_oid
+
+COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary);
+\COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary)
+
+SELECT md5(a), length(a) FROM x;
+
+TRUNCATE x;
+COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary);
+COPY x TO '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+\COPY x TO '@abs_builddir@/results/hash3.data' (FORMAT raw_binary)
+
+-- read again
+COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+\COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw_binary)
+-- cross
+COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw_binary);
+\COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary)
+
+SELECT md5(a), length(a) FROM x;
+
+DROP TABLE x;
+
+-- insert into multicolumn table
+CREATE TABLE x(id serial, a bytea, b bytea);
+
+-- should fail, too much columns
+COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+
+-- should work
+COPY x(a) FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+COPY x(b) FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+SELECT id, md5(a), md5(b) FROM x;
+
+-- test raw_text
+COPY (SELECT a FROM x WHERE id = 1) TO '@abs_builddir@/results/hash4.data' (FORMAT raw_text);
+COPY x(a) FROM '@abs_builddir@/results/hash4.data' (FORMAT raw_text);
+SELECT id, md5(a) FROM x WHERE id = lastval();
+
+DROP TABLE x;
+
diff --git a/src/test/regress/output/copy.source b/src/test/regress/output/copy.source
index b7e372d..e34bbab 100644
--- a/src/test/regress/output/copy.source
+++ b/src/test/regress/output/copy.source
@@ -95,3 +95,114 @@ copy copytest3 to stdout csv header;
 c1,"col with , comma","col with "" quote"
 1,a,1
 2,b,2
+-- copy raw
+CREATE TABLE x(a bytea);
+INSERT INTO x VALUES('\x41484f4a0a');
+SELECT length(a) FROM x;
+ length 
+--------
+      5
+(1 row)
+
+INSERT INTO x VALUES('\x41484f4a0a');
+-- should to fail
+COPY (SELECT a,a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ERROR:  Single column result/target is required in RAW_TEXT/RAW_BINARY mode
+COPY (SELECT a FROM x) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+ERROR:  single row result is required by RAW_TEXT/RAW_BINARY mode
+-- should be ok
+COPY (SELECT a FROM x LIMIT 1) TO '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+TRUNCATE x;
+COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw_binary);
+SELECT length(a) FROM x;
+ length 
+--------
+      5
+(1 row)
+
+COPY x TO stdout (FORMAT raw_binary);
+AHOJ
+TRUNCATE x;
+\COPY x FROM '@abs_builddir@/results/raw.data' (FORMAT raw_binary)
+SELECT length(a) FROM x;
+ length 
+--------
+      5
+(1 row)
+
+COPY x TO stdout (FORMAT raw_binary);
+AHOJ
+\COPY x TO '@abs_builddir@/results/raw2.data' (FORMAT raw_binary)
+TRUNCATE x;
+\COPY x FROM '@abs_builddir@/results/raw2.data' (FORMAT raw_binary)
+SELECT length(a) FROM x;
+ length 
+--------
+      5
+(1 row)
+
+COPY x TO stdout (FORMAT raw_binary);
+AHOJ
+-- test big file
+TRUNCATE x;
+-- use different mechanism for load to bytea
+\lo_import @abs_builddir@/data/hash.data
+\set lo_oid :LASTOID
+INSERT INTO x VALUES(lo_get(:lo_oid));
+\lo_unlink :lo_oid
+COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary);
+\COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary)
+SELECT md5(a), length(a) FROM x;
+               md5                | length 
+----------------------------------+--------
+ e446fe6ea5a347e69670633412c7f8cb | 153749
+ e446fe6ea5a347e69670633412c7f8cb | 153749
+ e446fe6ea5a347e69670633412c7f8cb | 153749
+(3 rows)
+
+TRUNCATE x;
+COPY x FROM '@abs_builddir@/data/hash.data' (FORMAT raw_binary);
+COPY x TO '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+\COPY x TO '@abs_builddir@/results/hash3.data' (FORMAT raw_binary)
+-- read again
+COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+\COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw_binary)
+-- cross
+COPY x FROM '@abs_builddir@/results/hash3.data' (FORMAT raw_binary);
+\COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary)
+SELECT md5(a), length(a) FROM x;
+               md5                | length 
+----------------------------------+--------
+ e446fe6ea5a347e69670633412c7f8cb | 153749
+ e446fe6ea5a347e69670633412c7f8cb | 153749
+ e446fe6ea5a347e69670633412c7f8cb | 153749
+ e446fe6ea5a347e69670633412c7f8cb | 153749
+ e446fe6ea5a347e69670633412c7f8cb | 153749
+(5 rows)
+
+DROP TABLE x;
+-- insert into multicolumn table
+CREATE TABLE x(id serial, a bytea, b bytea);
+-- should fail, too much columns
+COPY x FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+ERROR:  Single column result/target is required in RAW_TEXT/RAW_BINARY mode
+-- should work
+COPY x(a) FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+COPY x(b) FROM '@abs_builddir@/results/hash2.data' (FORMAT raw_binary);
+SELECT id, md5(a), md5(b) FROM x;
+ id |               md5                |               md5                
+----+----------------------------------+----------------------------------
+  1 | e446fe6ea5a347e69670633412c7f8cb | 
+  2 |                                  | e446fe6ea5a347e69670633412c7f8cb
+(2 rows)
+
+-- test raw_text
+COPY (SELECT a FROM x WHERE id = 1) TO '@abs_builddir@/results/hash4.data' (FORMAT raw_text);
+COPY x(a) FROM '@abs_builddir@/results/hash4.data' (FORMAT raw_text);
+SELECT id, md5(a) FROM x WHERE id = lastval();
+ id |               md5                
+----+----------------------------------
+  3 | e446fe6ea5a347e69670633412c7f8cb
+(1 row)
+
+DROP TABLE x;
diff --git a/src/test/regress/sql/copy2.sql b/src/test/regress/sql/copy2.sql
index 39a9deb..7e22ee4 100644
--- a/src/test/regress/sql/copy2.sql
+++ b/src/test/regress/sql/copy2.sql
@@ -333,3 +333,16 @@ DROP FUNCTION truncate_in_subxact();
 DROP TABLE x, y;
 DROP FUNCTION fn_x_before();
 DROP FUNCTION fn_x_after();
+
+CREATE TABLE x(a bytea);
+INSERT INTO x VALUES('\x41484f4a0a');
+INSERT INTO x VALUES('\x41484f4a0a');
+
+-- should to fail
+COPY (SELECT a,a FROM x LIMIT 1) TO STDOUT (FORMAT raw_binary);
+COPY (SELECT a FROM x) TO STDOUT (FORMAT raw_binary);
+
+-- should be ok
+COPY (SELECT a FROM x LIMIT 1) TO STDOUT (FORMAT raw_binary);
+
+DROP TABLE x;