}
/* --------------------------------
- * pq_sendbyte - append a raw byte to a StringInfo buffer
+
+ * pq_beginmessage_reuse - initialize for sending a message, reuse buffer
+ *
+ * This requires the buffer to be allocated in an sufficiently long-lived
+ * memory context.
* --------------------------------
*/
void
-pq_sendbyte(StringInfo buf, int byt)
+pq_beginmessage_reuse(StringInfo buf, char msgtype)
{
- appendStringInfoCharMacro(buf, byt);
+ resetStringInfo(buf);
+
+ /*
+ * We stash the message type into the buffer's cursor field, expecting
+ * that the pq_sendXXX routines won't touch it. We could alternatively
+ * make it the first byte of the buffer contents, but this seems easier.
+ */
+ buf->cursor = msgtype;
}
/* --------------------------------
void
pq_sendbytes(StringInfo buf, const char *data, int datalen)
{
+ /* use variant that maintains a trailing null-byte, out of caution */
appendBinaryStringInfo(buf, data, datalen);
}
if (p != str) /* actual conversion has been done? */
{
slen = strlen(p);
- pq_sendint(buf, slen + extra, 4);
+ pq_sendint32(buf, slen + extra);
appendBinaryStringInfoNT(buf, p, slen);
pfree(p);
}
else
{
- pq_sendint(buf, slen + extra, 4);
+ pq_sendint32(buf, slen + extra);
appendBinaryStringInfoNT(buf, str, slen);
}
}
appendStringInfoChar(buf, '\0');
}
-/* --------------------------------
- * pq_sendint - append a binary integer to a StringInfo buffer
- * --------------------------------
- */
-void
-pq_sendint(StringInfo buf, int i, int b)
-{
- unsigned char n8;
- uint16 n16;
- uint32 n32;
-
- switch (b)
- {
- case 1:
- n8 = (unsigned char) i;
- appendBinaryStringInfoNT(buf, (char *) &n8, 1);
- break;
- case 2:
- n16 = pg_hton16((uint16) i);
- appendBinaryStringInfoNT(buf, (char *) &n16, 2);
- break;
- case 4:
- n32 = pg_hton32((uint32) i);
- appendBinaryStringInfoNT(buf, (char *) &n32, 4);
- break;
- default:
- elog(ERROR, "unsupported integer size %d", b);
- break;
- }
-}
-
-/* --------------------------------
- * pq_sendint64 - append a binary 8-byte int to a StringInfo buffer
- *
- * It is tempting to merge this with pq_sendint, but we'd have to make the
- * argument int64 for all data widths --- that could be a big performance
- * hit on machines where int64 isn't efficient.
- * --------------------------------
- */
-void
-pq_sendint64(StringInfo buf, int64 i)
-{
- uint64 n64 = pg_hton64(i);
-
- appendBinaryStringInfoNT(buf, (char *) &n64, sizeof(n64));
-}
-
/* --------------------------------
* pq_sendfloat4 - append a float4 to a StringInfo buffer
*
} swap;
swap.f = f;
- swap.i = pg_hton32(swap.i);
-
- appendBinaryStringInfoNT(buf, (char *) &swap.i, 4);
+ pq_sendint32(buf, swap.i);
}
/* --------------------------------
buf->data = NULL;
}
+/* --------------------------------
+ * pq_endmessage_reuse - send the completed message to the frontend
+ *
+ * The data buffer is *not* freed, allowing to reuse the buffer with
+ * pg_beginmessage_reuse.
+ --------------------------------
+ */
+
+void
+pq_endmessage_reuse(StringInfo buf)
+{
+ /* msgtype was saved in cursor field */
+ (void) pq_putmessage(buf->cursor, buf->data, buf->len);
+}
+
/* --------------------------------
* pq_begintypsend - initialize for constructing a bytea result
#define PQFORMAT_H
#include "lib/stringinfo.h"
+#include "mb/pg_wchar.h"
+#include "port/pg_bswap.h"
extern void pq_beginmessage(StringInfo buf, char msgtype);
-extern void pq_sendbyte(StringInfo buf, int byt);
+extern void pq_beginmessage_reuse(StringInfo buf, char msgtype);
+extern void pq_endmessage(StringInfo buf);
+extern void pq_endmessage_reuse(StringInfo buf);
+
extern void pq_sendbytes(StringInfo buf, const char *data, int datalen);
extern void pq_sendcountedtext(StringInfo buf, const char *str, int slen,
bool countincludesself);
extern void pq_sendtext(StringInfo buf, const char *str, int slen);
extern void pq_sendstring(StringInfo buf, const char *str);
extern void pq_send_ascii_string(StringInfo buf, const char *str);
-extern void pq_sendint(StringInfo buf, int i, int b);
-extern void pq_sendint64(StringInfo buf, int64 i);
extern void pq_sendfloat4(StringInfo buf, float4 f);
extern void pq_sendfloat8(StringInfo buf, float8 f);
-extern void pq_endmessage(StringInfo buf);
+
+extern void pq_sendfloat4(StringInfo buf, float4 f);
+extern void pq_sendfloat8(StringInfo buf, float8 f);
+
+/*
+ * Append a int8 to a StringInfo buffer, which already has enough space
+ * preallocated.
+ *
+ * The use of restrict allows the compiler to optimize the code based on the
+ * assumption that buf, buf->len, buf->data and *buf->data don't
+ * overlap. Without the annotation buf->len etc cannot be kept in a register
+ * over subsequent pq_writeint* calls.
+ */
+static inline void
+pq_writeint8(StringInfo restrict buf, int8 i)
+{
+ int8 ni = i;
+
+ Assert(buf->len + sizeof(i) <= buf->maxlen);
+ memcpy((char *restrict) (buf->data + buf->len), &ni, sizeof(ni));
+ buf->len += sizeof(i);
+}
+
+/*
+ * Append a int16 to a StringInfo buffer, which already has enough space
+ * preallocated.
+ */
+static inline void
+pq_writeint16(StringInfo restrict buf, int16 i)
+{
+ int16 ni = pg_hton16(i);
+
+ Assert(buf->len + sizeof(ni) <= buf->maxlen);
+ memcpy((char *restrict) (buf->data + buf->len), &ni, sizeof(i));
+ buf->len += sizeof(i);
+}
+
+/*
+ * Append a int32 to a StringInfo buffer, which already has enough space
+ * preallocated.
+ */
+static inline void
+pq_writeint32(StringInfo restrict buf, int32 i)
+{
+ int32 ni = pg_hton32(i);
+
+ Assert(buf->len + sizeof(i) <= buf->maxlen);
+ memcpy((char *restrict) (buf->data + buf->len), &ni, sizeof(i));
+ buf->len += sizeof(i);
+}
+
+/*
+ * Append a int64 to a StringInfo buffer, which already has enough space
+ * preallocated.
+ */
+static inline void
+pq_writeint64(StringInfo restrict buf, int64 i)
+{
+ int64 ni = pg_hton64(i);
+
+ Assert(buf->len + sizeof(i) <= buf->maxlen);
+ memcpy((char *restrict) (buf->data + buf->len), &ni, sizeof(i));
+ buf->len += sizeof(i);
+}
+
+/*
+ * Append a null-terminated text string (with conversion) to a buffer with
+ * preallocated space.
+ *
+ * NB: The pre-allocated space needs to be sufficient for the string after
+ * converting to client encoding.
+ *
+ * NB: passed text string must be null-terminated, and so is the data
+ * sent to the frontend.
+ */
+static inline void
+pq_writestring(StringInfo restrict buf, const char *restrict str)
+{
+ int slen = strlen(str);
+ char *p;
+
+ p = pg_server_to_client(str, slen);
+ if (p != str) /* actual conversion has been done? */
+ slen = strlen(p);
+
+ Assert(buf->len + slen + 1 <= buf->maxlen);
+
+ memcpy(((char *restrict) buf->data + buf->len), p, slen + 1);
+ buf->len += slen + 1;
+
+ if (p != str)
+ pfree(p);
+}
+
+/* append a binary int8 to a StringInfo buffer */
+static inline void
+pq_sendint8(StringInfo buf, int8 i)
+{
+ enlargeStringInfo(buf, sizeof(i));
+ pq_writeint8(buf, i);
+}
+
+/* append a binary int16 to a StringInfo buffer */
+static inline void
+pq_sendint16(StringInfo buf, int16 i)
+{
+ enlargeStringInfo(buf, sizeof(i));
+ pq_writeint16(buf, i);
+}
+
+/* append a binary int32 to a StringInfo buffer */
+static inline void
+pq_sendint32(StringInfo buf, int32 i)
+{
+ enlargeStringInfo(buf, sizeof(i));
+ pq_writeint32(buf, i);
+}
+
+/* append a binary int64 to a StringInfo buffer */
+static inline void
+pq_sendint64(StringInfo buf, int64 i)
+{
+ enlargeStringInfo(buf, sizeof(i));
+ pq_writeint64(buf, i);
+}
+
+/* append a binary byte to a StringInfo buffer */
+static inline void
+pq_sendbyte(StringInfo buf, int8 byt)
+{
+ pq_sendint8(buf, byt);
+}
+
+/*
+ * Append a binary integer to a StringInfo buffer
+ *
+ * This function is deprecated.
+ */
+static inline void
+pq_sendint(StringInfo buf, int i, int b)
+{
+ switch (b)
+ {
+ case 1:
+ pq_sendint8(buf, (int8) i);
+ break;
+ case 2:
+ pq_sendint16(buf, (int16) i);
+ break;
+ case 4:
+ pq_sendint32(buf, (int32) i);
+ break;
+ default:
+ elog(ERROR, "unsupported integer size %d", b);
+ break;
+ }
+}
+
extern void pq_begintypsend(StringInfo buf);
extern bytea *pq_endtypsend(StringInfo buf);
projects / postgresql / commitdiff