Add bytea datatype to ECPG.

So far ECPG programs had to treat binary data for bytea column as 'char' type.
But this meant converting from/to escaped format with PQunescapeBytea/
PQescapeBytea() and therefore forcing users to add unnecessary code and cost
for the conversion in runtime. By adding a dedicated datatype for bytea most of
this special handling is no longer needed.

Author: Matsumura-san ("Matsumura, Ryo" <matsumura.ryo@jp.fujitsu.com>)

Discussion: https://postgr.es/m/flat/03040DFF97E6E54E88D3BFEE5F5480F737A141F9@G01JPEXMBYT04

Author: Michael Meskes

doc/src/sgml/ecpg.sgml

@@ -917,7 +917,7 @@ do
 
       <row>
        <entry><type>character(<replaceable>n</replaceable>)</type>, <type>varchar(<replaceable>n</replaceable>)</type>, <type>text</type></entry>
-       <entry><type>char[<replaceable>n</replaceable>+1]</type>, <type>VARCHAR[<replaceable>n</replaceable>+1]</type><footnote><para>declared in <filename>ecpglib.h</filename></para></footnote></entry>
+       <entry><type>char[<replaceable>n</replaceable>+1]</type>, <type>VARCHAR[<replaceable>n</replaceable>+1]</type></entry>
       </row>
 
       <row>
@@ -947,7 +947,7 @@ do
 
       <row>
        <entry><type>bytea</type></entry>
-       <entry><type>char *</type></entry>
+       <entry><type>char *</type>, <type>bytea[<replaceable>n</replaceable>]</type></entry>
       </row>
      </tbody>
     </tgroup>
@@ -1204,6 +1204,36 @@ EXEC SQL END DECLARE SECTION;
 </programlisting>
      </para>
     </sect4>
+
+    <sect4>
+     <title id="ecpg-type-bytea">bytea</title>
+
+     <para>
+      The handling of the <type>bytea</type> type is also similar to
+      the <type>VARCHAR</type>. The definition on an array of type
+      <type>bytea</type> is converted into a named struct for every
+      variable. A declaration like:
+<programlisting>
+bytea var[180];
+</programlisting>
+     is converted into:
+<programlisting>
+struct bytea_var { int len; char arr[180]; } var;
+</programlisting>
+      The member <structfield>arr</structfield> hosts binary format
+      data. It also can handle even <literal>'\0'</literal> as part of
+      data unlike <type>VARCHAR</type>.
+      The data is converted from/to hex format and sent/received by
+      ecpglib.
+     </para>
+
+     <note>
+      <para>
+       <type>bytea</type> variable can be used only when
+       <xref linkend="guc-bytea-output"/> is set to <literal>hex</literal>.
+      </para>
+     </note>
+    </sect4>
    </sect3>
 
    <sect3 id="ecpg-variables-nonprimitive-c">

src/interfaces/ecpg/ecpglib/data.c

@@ -122,6 +122,86 @@ check_special_value(char *ptr, double *retval, char **endptr)
 	return false;
 }
 
+/* imported from src/backend/utils/adt/encode.c */
+
+unsigned
+ecpg_hex_enc_len(unsigned srclen)
+{
+	return srclen << 1;
+}
+
+unsigned
+ecpg_hex_dec_len(unsigned srclen)
+{
+	return srclen >> 1;
+}
+
+static inline char
+get_hex(char c)
+{
+	static const int8 hexlookup[128] = {
+		-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+		-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+		-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+		0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
+		-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+		-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+		-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+		-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+	};
+	int			res = -1;
+
+	if (c > 0 && c < 127)
+		res = hexlookup[(unsigned char) c];
+
+	return (char) res;
+}
+
+static unsigned
+hex_decode(const char *src, unsigned len, char *dst)
+{
+	const char *s,
+			   *srcend;
+	char		v1,
+				v2,
+			   *p;
+
+	srcend = src + len;
+	s = src;
+	p = dst;
+	while (s < srcend)
+	{
+		if (*s == ' ' || *s == '\n' || *s == '\t' || *s == '\r')
+		{
+			s++;
+			continue;
+		}
+		v1 = get_hex(*s++) << 4;
+		if (s >= srcend)
+			return -1;
+
+		v2 = get_hex(*s++);
+		*p++ = v1 | v2;
+	}
+
+	return p - dst;
+}
+
+unsigned
+ecpg_hex_encode(const char *src, unsigned len, char *dst)
+{
+	static const char hextbl[] = "0123456789abcdef";
+	const char *end = src + len;
+
+	while (src < end)
+	{
+		*dst++ = hextbl[(*src >> 4) & 0xF];
+		*dst++ = hextbl[*src & 0xF];
+		src++;
+	}
+	return len * 2;
+}
+
 bool
 ecpg_get_data(const PGresult *results, int act_tuple, int act_field, int lineno,
 			  enum ECPGttype type, enum ECPGttype ind_type,
@@ -447,6 +527,55 @@ ecpg_get_data(const PGresult *results, int act_tuple, int act_field, int lineno,
 					return false;
 					break;
 
+				case ECPGt_bytea:
+					{
+						struct ECPGgeneric_varchar *variable =
+						(struct ECPGgeneric_varchar *) (var + offset * act_tuple);
+						long		dst_size,
+									src_size,
+									dec_size;
+
+						dst_size = ecpg_hex_enc_len(varcharsize);
+						src_size = size - 2;	/* exclude backslash + 'x' */
+						dec_size = src_size < dst_size ? src_size : dst_size;
+						variable->len = hex_decode(pval + 2, dec_size, variable->arr);
+
+						if (dst_size < src_size)
+						{
+							long		rcv_size = ecpg_hex_dec_len(size - 2);
+
+							/* truncation */
+							switch (ind_type)
+							{
+								case ECPGt_short:
+								case ECPGt_unsigned_short:
+									*((short *) (ind + ind_offset * act_tuple)) = rcv_size;
+									break;
+								case ECPGt_int:
+								case ECPGt_unsigned_int:
+									*((int *) (ind + ind_offset * act_tuple)) = rcv_size;
+									break;
+								case ECPGt_long:
+								case ECPGt_unsigned_long:
+									*((long *) (ind + ind_offset * act_tuple)) = rcv_size;
+									break;
+#ifdef HAVE_LONG_LONG_INT
+								case ECPGt_long_long:
+								case ECPGt_unsigned_long_long:
+									*((long long int *) (ind + ind_offset * act_tuple)) = rcv_size;
+									break;
+#endif							/* HAVE_LONG_LONG_INT */
+								default:
+									break;
+							}
+							sqlca->sqlwarn[0] = sqlca->sqlwarn[1] = 'W';
+						}
+
+						pval += size;
+
+					}
+					break;
+
 				case ECPGt_char:
 				case ECPGt_unsigned_char:
 				case ECPGt_string:

src/interfaces/ecpg/ecpglib/descriptor.c

@@ -587,6 +587,28 @@ ECPGset_desc_header(int lineno, const char *desc_name, int count)
 	return true;
 }
 
+static void
+set_desc_attr(struct descriptor_item *desc_item, struct variable *var,
+				char *tobeinserted)
+{
+	if (var->type != ECPGt_bytea)
+		desc_item->is_binary = false;
+
+	else
+	{
+		struct ECPGgeneric_varchar *variable =
+		(struct ECPGgeneric_varchar *) (var->value);
+
+		desc_item->is_binary = true;
+		desc_item->data_len = variable->len;
+	}
+
+	ecpg_free(desc_item->data); /* free() takes care of a
+								 * potential NULL value */
+	desc_item->data = (char *) tobeinserted;
+}
+
+
 bool
 ECPGset_desc(int lineno, const char *desc_name, int index,...)
 {
@@ -666,9 +688,7 @@ ECPGset_desc(int lineno, const char *desc_name, int index,...)
 						return false;
 					}
 
-					ecpg_free(desc_item->data); /* free() takes care of a
-												 * potential NULL value */
-					desc_item->data = (char *) tobeinserted;
+					set_desc_attr(desc_item, var, tobeinserted);
 					tobeinserted = NULL;
 					break;
 				}

src/interfaces/ecpg/ecpglib/ecpglib_extern.h

@@ -40,6 +40,13 @@ struct ECPGgeneric_varchar
 	char		arr[FLEXIBLE_ARRAY_MEMBER];
 };
 
+/* A generic bytea type. */
+struct ECPGgeneric_bytea
+{
+	int			len;
+	char		arr[FLEXIBLE_ARRAY_MEMBER];
+};
+
 /*
  * type information cache
  */
@@ -75,6 +82,8 @@ struct statement
 #endif
 	int			nparams;
 	char	  **paramvalues;
+	int		   *paramlengths;
+	int		   *paramformats;
 	PGresult   *results;
 };
 
@@ -133,6 +142,8 @@ struct descriptor_item
 	int			precision;
 	int			scale;
 	int			type;
+	bool		is_binary;
+	int			data_len;
 	struct descriptor_item *next;
 };
 
@@ -226,6 +237,9 @@ struct sqlda_compat *ecpg_build_compat_sqlda(int, PGresult *, int, enum COMPAT_M
 void		ecpg_set_compat_sqlda(int, struct sqlda_compat **, const PGresult *, int, enum COMPAT_MODE);
 struct sqlda_struct *ecpg_build_native_sqlda(int, PGresult *, int, enum COMPAT_MODE);
 void		ecpg_set_native_sqlda(int, struct sqlda_struct **, const PGresult *, int, enum COMPAT_MODE);
+unsigned	ecpg_hex_dec_len(unsigned srclen);
+unsigned	ecpg_hex_enc_len(unsigned srclen);
+unsigned	ecpg_hex_encode(const char *src, unsigned len, char *dst);
 
 /* SQLSTATE values generated or processed by ecpglib (intentionally
  * not exported -- users should refer to the codes directly) */