Replace remaining uses of pq_sendint with pq_sendint{8,16,32}.

pq_sendint() remains, so extension code doesn't unnecessarily break.

Author: Andres Freund
Discussion: https://postgr.es/m/20170914063418.sckdzgjfrsbekae4@alap3.anarazel.de

diff --git a/contrib/hstore/hstore_io.c b/contrib/hstore/hstore_io.c
index 6363c321c5d0f825287fb162c68c37c1bf68901c..d8284012d0b53e9ce7f1b5a06f504718a72dec4a 100644 (file)
--- a/contrib/hstore/hstore_io.c
+++ b/contrib/hstore/hstore_io.c
@@ -1207,23 +1207,23 @@ hstore_send(PG_FUNCTION_ARGS)
 
        pq_begintypsend(&buf);
 
-       pq_sendint(&buf, count, 4);
+       pq_sendint32(&buf, count);
 
        for (i = 0; i < count; i++)
        {
                int32           keylen = HSTORE_KEYLEN(entries, i);
 
-               pq_sendint(&buf, keylen, 4);
+               pq_sendint32(&buf, keylen);
                pq_sendtext(&buf, HSTORE_KEY(entries, base, i), keylen);
                if (HSTORE_VALISNULL(entries, i))
                {
-                       pq_sendint(&buf, -1, 4);
+                       pq_sendint32(&buf, -1);
                }
                else
                {
                        int32           vallen = HSTORE_VALLEN(entries, i);
 
-                       pq_sendint(&buf, vallen, 4);
+                       pq_sendint32(&buf, vallen);
                        pq_sendtext(&buf, HSTORE_VAL(entries, base, i), vallen);
                }
        }

diff --git a/src/backend/access/common/printsimple.c b/src/backend/access/common/printsimple.c
index b3e9a26b0327c69d1441ae5eb3934cffdfff0e06..872de7c3f4467388652acfbb0616b6be7bed9a2b 100644 (file)
--- a/src/backend/access/common/printsimple.c
+++ b/src/backend/access/common/printsimple.c
@@ -34,19 +34,19 @@ printsimple_startup(DestReceiver *self, int operation, TupleDesc tupdesc)
        int                     i;
 
        pq_beginmessage(&buf, 'T'); /* RowDescription */
-       pq_sendint(&buf, tupdesc->natts, 2);
+       pq_sendint16(&buf, tupdesc->natts);
 
        for (i = 0; i < tupdesc->natts; ++i)
        {
                Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
 
                pq_sendstring(&buf, NameStr(attr->attname));
-               pq_sendint(&buf, 0, 4); /* table oid */
-               pq_sendint(&buf, 0, 2); /* attnum */
-               pq_sendint(&buf, (int) attr->atttypid, 4);
-               pq_sendint(&buf, attr->attlen, 2);
-               pq_sendint(&buf, attr->atttypmod, 4);
-               pq_sendint(&buf, 0, 2); /* format code */
+               pq_sendint32(&buf, 0); /* table oid */
+               pq_sendint16(&buf, 0); /* attnum */
+               pq_sendint32(&buf, (int) attr->atttypid);
+               pq_sendint16(&buf, attr->attlen);
+               pq_sendint32(&buf, attr->atttypmod);
+               pq_sendint16(&buf, 0); /* format code */
        }
 
        pq_endmessage(&buf);
@@ -67,7 +67,7 @@ printsimple(TupleTableSlot *slot, DestReceiver *self)
 
        /* Prepare and send message */
        pq_beginmessage(&buf, 'D');
-       pq_sendint(&buf, tupdesc->natts, 2);
+       pq_sendint16(&buf, tupdesc->natts);
 
        for (i = 0; i < tupdesc->natts; ++i)
        {
@@ -76,7 +76,7 @@ printsimple(TupleTableSlot *slot, DestReceiver *self)
 
                if (slot->tts_isnull[i])
                {
-                       pq_sendint(&buf, -1, 4);
+                       pq_sendint32(&buf, -1);
                        continue;
                }
 

diff --git a/src/backend/access/common/printtup.c b/src/backend/access/common/printtup.c
index 02cd1beef79b774326c26fe0e62919e414205583..fc94e711b27f97c724f155cdcc17b91241360850 100644 (file)
--- a/src/backend/access/common/printtup.c
+++ b/src/backend/access/common/printtup.c
@@ -395,7 +395,7 @@ printtup(TupleTableSlot *slot, DestReceiver *self)
         */
        pq_beginmessage_reuse(buf, 'D');
 
-       pq_sendint(buf, natts, 2);
+       pq_sendint16(buf, natts);
 
        /*
         * send the attributes of this tuple
@@ -407,7 +407,7 @@ printtup(TupleTableSlot *slot, DestReceiver *self)
 
                if (slot->tts_isnull[i])
                {
-                       pq_sendint(buf, -1, 4);
+                       pq_sendint32(buf, -1);
                        continue;
                }
 
@@ -436,7 +436,7 @@ printtup(TupleTableSlot *slot, DestReceiver *self)
                        bytea      *outputbytes;
 
                        outputbytes = SendFunctionCall(&thisState->finfo, attr);
-                       pq_sendint(buf, VARSIZE(outputbytes) - VARHDRSZ, 4);
+                       pq_sendint32(buf, VARSIZE(outputbytes) - VARHDRSZ);
                        pq_sendbytes(buf, VARDATA(outputbytes),
                                                 VARSIZE(outputbytes) - VARHDRSZ);
                }
@@ -494,13 +494,13 @@ printtup_20(TupleTableSlot *slot, DestReceiver *self)
                k >>= 1;
                if (k == 0)                             /* end of byte? */
                {
-                       pq_sendint(buf, j, 1);
+                       pq_sendint8(buf, j);
                        j = 0;
                        k = 1 << 7;
                }
        }
        if (k != (1 << 7))                      /* flush last partial byte */
-               pq_sendint(buf, j, 1);
+               pq_sendint8(buf, j);
 
        /*
         * send the attributes of this tuple
@@ -679,13 +679,13 @@ printtup_internal_20(TupleTableSlot *slot, DestReceiver *self)
                k >>= 1;
                if (k == 0)                             /* end of byte? */
                {
-                       pq_sendint(buf, j, 1);
+                       pq_sendint8(buf, j);
                        j = 0;
                        k = 1 << 7;
                }
        }
        if (k != (1 << 7))                      /* flush last partial byte */
-               pq_sendint(buf, j, 1);
+               pq_sendint8(buf, j);
 
        /*
         * send the attributes of this tuple
@@ -702,7 +702,7 @@ printtup_internal_20(TupleTableSlot *slot, DestReceiver *self)
                Assert(thisState->format == 1);
 
                outputbytes = SendFunctionCall(&thisState->finfo, attr);
-               pq_sendint(buf, VARSIZE(outputbytes) - VARHDRSZ, 4);
+               pq_sendint32(buf, VARSIZE(outputbytes) - VARHDRSZ);
                pq_sendbytes(buf, VARDATA(outputbytes),
                                         VARSIZE(outputbytes) - VARHDRSZ);
        }

diff --git a/src/backend/access/transam/parallel.c b/src/backend/access/transam/parallel.c
index c6f7b7af0e1fd21954f5f835bd8e9de2aa98d4e9..d68305073303d23bf7f647cdad5d28e4d006da50 100644 (file)
--- a/src/backend/access/transam/parallel.c
+++ b/src/backend/access/transam/parallel.c
@@ -1030,8 +1030,8 @@ ParallelWorkerMain(Datum main_arg)
         * in this case.
         */
        pq_beginmessage(&msgbuf, 'K');
-       pq_sendint(&msgbuf, (int32) MyProcPid, sizeof(int32));
-       pq_sendint(&msgbuf, (int32) MyCancelKey, sizeof(int32));
+       pq_sendint32(&msgbuf, (int32) MyProcPid);
+       pq_sendint32(&msgbuf, (int32) MyCancelKey);
        pq_endmessage(&msgbuf);
 
        /*

diff --git a/src/backend/commands/async.c b/src/backend/commands/async.c
index a93c81bca28798e64ef84be847eecf12c6c6c740..f7de742a56e7f8e11ff6df9aae02bfd0584448be 100644 (file)
--- a/src/backend/commands/async.c
+++ b/src/backend/commands/async.c
@@ -2100,7 +2100,7 @@ NotifyMyFrontEnd(const char *channel, const char *payload, int32 srcPid)
                StringInfoData buf;
 
                pq_beginmessage(&buf, 'A');
-               pq_sendint(&buf, srcPid, sizeof(int32));
+               pq_sendint32(&buf, srcPid);
                pq_sendstring(&buf, channel);
                if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 3)
                        pq_sendstring(&buf, payload);

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index e87588040fafb418433bfd88c9f59fca506e7516..64550f9c680a17c926861ae7755420c8da85476e 100644 (file)
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -357,9 +357,9 @@ SendCopyBegin(CopyState cstate)
 
                pq_beginmessage(&buf, 'H');
                pq_sendbyte(&buf, format);      /* overall format */
-               pq_sendint(&buf, natts, 2);
+               pq_sendint16(&buf, natts);
                for (i = 0; i < natts; i++)
-                       pq_sendint(&buf, format, 2);    /* per-column formats */
+                       pq_sendint16(&buf, format);     /* per-column formats */
                pq_endmessage(&buf);
                cstate->copy_dest = COPY_NEW_FE;
        }
@@ -390,9 +390,9 @@ ReceiveCopyBegin(CopyState cstate)
 
                pq_beginmessage(&buf, 'G');
                pq_sendbyte(&buf, format);      /* overall format */
-               pq_sendint(&buf, natts, 2);
+               pq_sendint16(&buf, natts);
                for (i = 0; i < natts; i++)
-                       pq_sendint(&buf, format, 2);    /* per-column formats */
+                       pq_sendint16(&buf, format);     /* per-column formats */
                pq_endmessage(&buf);
                cstate->copy_dest = COPY_NEW_FE;
                cstate->fe_msgbuf = makeStringInfo();

diff --git a/src/backend/libpq/auth.c b/src/backend/libpq/auth.c
index 480e344eb3a45510b10a7983ab3d0bdf7f2de183..3b3a932a7d8aaab24d3a1920e3cb58fc32a9f0ab 100644 (file)
--- a/src/backend/libpq/auth.c
+++ b/src/backend/libpq/auth.c
@@ -613,7 +613,7 @@ sendAuthRequest(Port *port, AuthRequest areq, char *extradata, int extralen)
        CHECK_FOR_INTERRUPTS();
 
        pq_beginmessage(&buf, 'R');
-       pq_sendint(&buf, (int32) areq, sizeof(int32));
+       pq_sendint32(&buf, (int32) areq);
        if (extralen > 0)
                pq_sendbytes(&buf, extradata, extralen);
 

diff --git a/src/backend/replication/basebackup.c b/src/backend/replication/basebackup.c
index c3b9bddc8fe7592d01f1f61883b3e577e4047baa..75029b0def9911295b523161131edf8ce6769db7 100644 (file)
--- a/src/backend/replication/basebackup.c
+++ b/src/backend/replication/basebackup.c
@@ -274,7 +274,7 @@ perform_base_backup(basebackup_options *opt, DIR *tblspcdir)
                        /* Send CopyOutResponse message */
                        pq_beginmessage(&buf, 'H');
                        pq_sendbyte(&buf, 0);   /* overall format */
-                       pq_sendint(&buf, 0, 2); /* natts */
+                       pq_sendint16(&buf, 0); /* natts */
                        pq_endmessage(&buf);
 
                        if (ti->path == NULL)
@@ -722,7 +722,7 @@ send_int8_string(StringInfoData *buf, int64 intval)
        char            is[32];
 
        sprintf(is, INT64_FORMAT, intval);
-       pq_sendint(buf, strlen(is), 4);
+       pq_sendint32(buf, strlen(is));
        pq_sendbytes(buf, is, strlen(is));
 }
 
@@ -734,34 +734,34 @@ SendBackupHeader(List *tablespaces)
 
        /* Construct and send the directory information */
        pq_beginmessage(&buf, 'T'); /* RowDescription */
-       pq_sendint(&buf, 3, 2);         /* 3 fields */
+       pq_sendint16(&buf, 3);          /* 3 fields */
 
        /* First field - spcoid */
        pq_sendstring(&buf, "spcoid");
-       pq_sendint(&buf, 0, 4);         /* table oid */
-       pq_sendint(&buf, 0, 2);         /* attnum */
-       pq_sendint(&buf, OIDOID, 4);    /* type oid */
-       pq_sendint(&buf, 4, 2);         /* typlen */
-       pq_sendint(&buf, 0, 4);         /* typmod */
-       pq_sendint(&buf, 0, 2);         /* format code */
+       pq_sendint32(&buf, 0);          /* table oid */
+       pq_sendint16(&buf, 0);          /* attnum */
+       pq_sendint32(&buf, OIDOID);     /* type oid */
+       pq_sendint16(&buf, 4);          /* typlen */
+       pq_sendint32(&buf, 0);          /* typmod */
+       pq_sendint16(&buf, 0);          /* format code */
 
        /* Second field - spcpath */
        pq_sendstring(&buf, "spclocation");
-       pq_sendint(&buf, 0, 4);
-       pq_sendint(&buf, 0, 2);
-       pq_sendint(&buf, TEXTOID, 4);
-       pq_sendint(&buf, -1, 2);
-       pq_sendint(&buf, 0, 4);
-       pq_sendint(&buf, 0, 2);
+       pq_sendint32(&buf, 0);
+       pq_sendint16(&buf, 0);
+       pq_sendint32(&buf, TEXTOID);
+       pq_sendint16(&buf, -1);
+       pq_sendint32(&buf, 0);
+       pq_sendint16(&buf, 0);
 
        /* Third field - size */
        pq_sendstring(&buf, "size");
-       pq_sendint(&buf, 0, 4);
-       pq_sendint(&buf, 0, 2);
-       pq_sendint(&buf, INT8OID, 4);
-       pq_sendint(&buf, 8, 2);
-       pq_sendint(&buf, 0, 4);
-       pq_sendint(&buf, 0, 2);
+       pq_sendint32(&buf, 0);
+       pq_sendint16(&buf, 0);
+       pq_sendint32(&buf, INT8OID);
+       pq_sendint16(&buf, 8);
+       pq_sendint32(&buf, 0);
+       pq_sendint16(&buf, 0);
        pq_endmessage(&buf);
 
        foreach(lc, tablespaces)
@@ -770,28 +770,28 @@ SendBackupHeader(List *tablespaces)
 
                /* Send one datarow message */
                pq_beginmessage(&buf, 'D');
-               pq_sendint(&buf, 3, 2); /* number of columns */
+               pq_sendint16(&buf, 3); /* number of columns */
                if (ti->path == NULL)
                {
-                       pq_sendint(&buf, -1, 4);        /* Length = -1 ==> NULL */
-                       pq_sendint(&buf, -1, 4);
+                       pq_sendint32(&buf, -1); /* Length = -1 ==> NULL */
+                       pq_sendint32(&buf, -1);
                }
                else
                {
                        Size            len;
 
                        len = strlen(ti->oid);
-                       pq_sendint(&buf, len, 4);
+                       pq_sendint32(&buf, len);
                        pq_sendbytes(&buf, ti->oid, len);
 
                        len = strlen(ti->path);
-                       pq_sendint(&buf, len, 4);
+                       pq_sendint32(&buf, len);
                        pq_sendbytes(&buf, ti->path, len);
                }
                if (ti->size >= 0)
                        send_int8_string(&buf, ti->size / 1024);
                else
-                       pq_sendint(&buf, -1, 4);        /* NULL */
+                       pq_sendint32(&buf, -1); /* NULL */
 
                pq_endmessage(&buf);
        }
@@ -812,42 +812,42 @@ SendXlogRecPtrResult(XLogRecPtr ptr, TimeLineID tli)
        Size            len;
 
        pq_beginmessage(&buf, 'T'); /* RowDescription */
-       pq_sendint(&buf, 2, 2);         /* 2 fields */
+       pq_sendint16(&buf, 2);          /* 2 fields */
 
        /* Field headers */
        pq_sendstring(&buf, "recptr");
-       pq_sendint(&buf, 0, 4);         /* table oid */
-       pq_sendint(&buf, 0, 2);         /* attnum */
-       pq_sendint(&buf, TEXTOID, 4);   /* type oid */
-       pq_sendint(&buf, -1, 2);
-       pq_sendint(&buf, 0, 4);
-       pq_sendint(&buf, 0, 2);
+       pq_sendint32(&buf, 0);          /* table oid */
+       pq_sendint16(&buf, 0);          /* attnum */
+       pq_sendint32(&buf, TEXTOID);    /* type oid */
+       pq_sendint16(&buf, -1);
+       pq_sendint32(&buf, 0);
+       pq_sendint16(&buf, 0);
 
        pq_sendstring(&buf, "tli");
-       pq_sendint(&buf, 0, 4);         /* table oid */
-       pq_sendint(&buf, 0, 2);         /* attnum */
+       pq_sendint32(&buf, 0);          /* table oid */
+       pq_sendint16(&buf, 0);          /* attnum */
 
        /*
         * int8 may seem like a surprising data type for this, but in theory int4
         * would not be wide enough for this, as TimeLineID is unsigned.
         */
-       pq_sendint(&buf, INT8OID, 4);   /* type oid */
-       pq_sendint(&buf, -1, 2);
-       pq_sendint(&buf, 0, 4);
-       pq_sendint(&buf, 0, 2);
+       pq_sendint32(&buf, INT8OID);    /* type oid */
+       pq_sendint16(&buf, -1);
+       pq_sendint32(&buf, 0);
+       pq_sendint16(&buf, 0);
        pq_endmessage(&buf);
 
        /* Data row */
        pq_beginmessage(&buf, 'D');
-       pq_sendint(&buf, 2, 2);         /* number of columns */
+       pq_sendint16(&buf, 2);          /* number of columns */
 
        len = snprintf(str, sizeof(str),
                                   "%X/%X", (uint32) (ptr >> 32), (uint32) ptr);
-       pq_sendint(&buf, len, 4);
+       pq_sendint32(&buf, len);
        pq_sendbytes(&buf, str, len);
 
        len = snprintf(str, sizeof(str), "%u", tli);
-       pq_sendint(&buf, len, 4);
+       pq_sendint32(&buf, len);
        pq_sendbytes(&buf, str, len);
 
        pq_endmessage(&buf);

diff --git a/src/backend/replication/logical/proto.c b/src/backend/replication/logical/proto.c
index f19649b113c297bb91ace4fdfc41399899882079..9b126b295705d8d7423e976958b0f91b42822998 100644 (file)
--- a/src/backend/replication/logical/proto.c
+++ b/src/backend/replication/logical/proto.c
@@ -47,7 +47,7 @@ logicalrep_write_begin(StringInfo out, ReorderBufferTXN *txn)
        /* fixed fields */
        pq_sendint64(out, txn->final_lsn);
        pq_sendint64(out, txn->commit_time);
-       pq_sendint(out, txn->xid, 4);
+       pq_sendint32(out, txn->xid);
 }
 
 /*
@@ -145,7 +145,7 @@ logicalrep_write_insert(StringInfo out, Relation rel, HeapTuple newtuple)
                   rel->rd_rel->relreplident == REPLICA_IDENTITY_INDEX);
 
        /* use Oid as relation identifier */
-       pq_sendint(out, RelationGetRelid(rel), 4);
+       pq_sendint32(out, RelationGetRelid(rel));
 
        pq_sendbyte(out, 'N');          /* new tuple follows */
        logicalrep_write_tuple(out, rel, newtuple);
@@ -189,7 +189,7 @@ logicalrep_write_update(StringInfo out, Relation rel, HeapTuple oldtuple,
                   rel->rd_rel->relreplident == REPLICA_IDENTITY_INDEX);
 
        /* use Oid as relation identifier */
-       pq_sendint(out, RelationGetRelid(rel), 4);
+       pq_sendint32(out, RelationGetRelid(rel));
 
        if (oldtuple != NULL)
        {
@@ -258,7 +258,7 @@ logicalrep_write_delete(StringInfo out, Relation rel, HeapTuple oldtuple)
        pq_sendbyte(out, 'D');          /* action DELETE */
 
        /* use Oid as relation identifier */
-       pq_sendint(out, RelationGetRelid(rel), 4);
+       pq_sendint32(out, RelationGetRelid(rel));
 
        if (rel->rd_rel->relreplident == REPLICA_IDENTITY_FULL)
                pq_sendbyte(out, 'O');  /* old tuple follows */
@@ -303,7 +303,7 @@ logicalrep_write_rel(StringInfo out, Relation rel)
        pq_sendbyte(out, 'R');          /* sending RELATION */
 
        /* use Oid as relation identifier */
-       pq_sendint(out, RelationGetRelid(rel), 4);
+       pq_sendint32(out, RelationGetRelid(rel));
 
        /* send qualified relation name */
        logicalrep_write_namespace(out, RelationGetNamespace(rel));
@@ -360,7 +360,7 @@ logicalrep_write_typ(StringInfo out, Oid typoid)
        typtup = (Form_pg_type) GETSTRUCT(tup);
 
        /* use Oid as relation identifier */
-       pq_sendint(out, typoid, 4);
+       pq_sendint32(out, typoid);
 
        /* send qualified type name */
        logicalrep_write_namespace(out, typtup->typnamespace);
@@ -402,7 +402,7 @@ logicalrep_write_tuple(StringInfo out, Relation rel, HeapTuple tuple)
                        continue;
                nliveatts++;
        }
-       pq_sendint(out, nliveatts, 2);
+       pq_sendint16(out, nliveatts);
 
        /* try to allocate enough memory from the get-go */
        enlargeStringInfo(out, tuple->t_len +
@@ -522,7 +522,7 @@ logicalrep_write_attrs(StringInfo out, Relation rel)
                        continue;
                nliveatts++;
        }
-       pq_sendint(out, nliveatts, 2);
+       pq_sendint16(out, nliveatts);
 
        /* fetch bitmap of REPLICATION IDENTITY attributes */
        replidentfull = (rel->rd_rel->relreplident == REPLICA_IDENTITY_FULL);
@@ -551,10 +551,10 @@ logicalrep_write_attrs(StringInfo out, Relation rel)
                pq_sendstring(out, NameStr(att->attname));
 
                /* attribute type id */
-               pq_sendint(out, (int) att->atttypid, sizeof(att->atttypid));
+               pq_sendint32(out, (int) att->atttypid);
 
                /* attribute mode */
-               pq_sendint(out, att->atttypmod, sizeof(att->atttypmod));
+               pq_sendint32(out, att->atttypmod);
        }
 
        bms_free(idattrs);

diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c
index 1bf9be673b79d19e7582ef3731b2d9985fbed564..fe4e08593897d755e92e388607e8b9a04786452d 100644 (file)
--- a/src/backend/replication/walreceiver.c
+++ b/src/backend/replication/walreceiver.c
@@ -1272,10 +1272,10 @@ XLogWalRcvSendHSFeedback(bool immed)
        resetStringInfo(&reply_message);
        pq_sendbyte(&reply_message, 'h');
        pq_sendint64(&reply_message, GetCurrentTimestamp());
-       pq_sendint(&reply_message, xmin, 4);
-       pq_sendint(&reply_message, xmin_epoch, 4);
-       pq_sendint(&reply_message, catalog_xmin, 4);
-       pq_sendint(&reply_message, catalog_xmin_epoch, 4);
+       pq_sendint32(&reply_message, xmin);
+       pq_sendint32(&reply_message, xmin_epoch);
+       pq_sendint32(&reply_message, catalog_xmin);
+       pq_sendint32(&reply_message, catalog_xmin_epoch);
        walrcv_send(wrconn, reply_message.data, reply_message.len);
        if (TransactionIdIsValid(xmin) || TransactionIdIsValid(catalog_xmin))
                master_has_standby_xmin = true;

diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index 6ec4e631612f4d4228945822d084c9688b257451..fa1db748b5e54c7e84f726693b35fbb4c03f4f9e 100644 (file)
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -444,32 +444,32 @@ SendTimeLineHistory(TimeLineHistoryCmd *cmd)
 
        /* Send a RowDescription message */
        pq_beginmessage(&buf, 'T');
-       pq_sendint(&buf, 2, 2);         /* 2 fields */
+       pq_sendint16(&buf, 2);          /* 2 fields */
 
        /* first field */
        pq_sendstring(&buf, "filename");        /* col name */
-       pq_sendint(&buf, 0, 4);         /* table oid */
-       pq_sendint(&buf, 0, 2);         /* attnum */
-       pq_sendint(&buf, TEXTOID, 4);   /* type oid */
-       pq_sendint(&buf, -1, 2);        /* typlen */
-       pq_sendint(&buf, 0, 4);         /* typmod */
-       pq_sendint(&buf, 0, 2);         /* format code */
+       pq_sendint32(&buf, 0);          /* table oid */
+       pq_sendint16(&buf, 0);          /* attnum */
+       pq_sendint32(&buf, TEXTOID);    /* type oid */
+       pq_sendint16(&buf, -1);         /* typlen */
+       pq_sendint32(&buf, 0);          /* typmod */
+       pq_sendint16(&buf, 0);          /* format code */
 
        /* second field */
        pq_sendstring(&buf, "content"); /* col name */
-       pq_sendint(&buf, 0, 4);         /* table oid */
-       pq_sendint(&buf, 0, 2);         /* attnum */
-       pq_sendint(&buf, BYTEAOID, 4);  /* type oid */
-       pq_sendint(&buf, -1, 2);        /* typlen */
-       pq_sendint(&buf, 0, 4);         /* typmod */
-       pq_sendint(&buf, 0, 2);         /* format code */
+       pq_sendint32(&buf, 0);          /* table oid */
+       pq_sendint16(&buf, 0);          /* attnum */
+       pq_sendint32(&buf, BYTEAOID);   /* type oid */
+       pq_sendint16(&buf, -1);         /* typlen */
+       pq_sendint32(&buf, 0);          /* typmod */
+       pq_sendint16(&buf, 0);          /* format code */
        pq_endmessage(&buf);
 
        /* Send a DataRow message */
        pq_beginmessage(&buf, 'D');
-       pq_sendint(&buf, 2, 2);         /* # of columns */
+       pq_sendint16(&buf, 2);          /* # of columns */
        len = strlen(histfname);
-       pq_sendint(&buf, len, 4);       /* col1 len */
+       pq_sendint32(&buf, len);        /* col1 len */
        pq_sendbytes(&buf, histfname, len);
 
        fd = OpenTransientFile(path, O_RDONLY | PG_BINARY);
@@ -489,7 +489,7 @@ SendTimeLineHistory(TimeLineHistoryCmd *cmd)
                                (errcode_for_file_access(),
                                 errmsg("could not seek to beginning of file \"%s\": %m", path)));
 
-       pq_sendint(&buf, histfilelen, 4);       /* col2 len */
+       pq_sendint32(&buf, histfilelen);        /* col2 len */
 
        bytesleft = histfilelen;
        while (bytesleft > 0)
@@ -646,7 +646,7 @@ StartReplication(StartReplicationCmd *cmd)
                /* Send a CopyBothResponse message, and start streaming */
                pq_beginmessage(&buf, 'W');
                pq_sendbyte(&buf, 0);
-               pq_sendint(&buf, 0, 2);
+               pq_sendint16(&buf, 0);
                pq_endmessage(&buf);
                pq_flush();
 
@@ -1065,7 +1065,7 @@ StartLogicalReplication(StartReplicationCmd *cmd)
        /* Send a CopyBothResponse message, and start streaming */
        pq_beginmessage(&buf, 'W');
        pq_sendbyte(&buf, 0);
-       pq_sendint(&buf, 0, 2);
+       pq_sendint16(&buf, 0);
        pq_endmessage(&buf);
        pq_flush();
 

diff --git a/src/backend/tcop/fastpath.c b/src/backend/tcop/fastpath.c
index 8101ae74e0bfdb84b4fd029ccb6d22efeec1edf6..a434f7f857f0cbc05186b1f674809231c708b2cd 100644 (file)
--- a/src/backend/tcop/fastpath.c
+++ b/src/backend/tcop/fastpath.c
@@ -143,7 +143,7 @@ SendFunctionResult(Datum retval, bool isnull, Oid rettype, int16 format)
        if (isnull)
        {
                if (newstyle)
-                       pq_sendint(&buf, -1, 4);
+                       pq_sendint32(&buf, -1);
        }
        else
        {
@@ -169,7 +169,7 @@ SendFunctionResult(Datum retval, bool isnull, Oid rettype, int16 format)
 
                        getTypeBinaryOutputInfo(rettype, &typsend, &typisvarlena);
                        outputbytes = OidSendFunctionCall(typsend, retval);
-                       pq_sendint(&buf, VARSIZE(outputbytes) - VARHDRSZ, 4);
+                       pq_sendint32(&buf, VARSIZE(outputbytes) - VARHDRSZ);
                        pq_sendbytes(&buf, VARDATA(outputbytes),
                                                 VARSIZE(outputbytes) - VARHDRSZ);
                        pfree(outputbytes);

diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index 338ce81331d88657ef1d19a62bdccecbbd6dad23..2c7260e564bf246261a4e7e1ad35e9daa8a2fcd2 100644 (file)
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -2376,13 +2376,13 @@ exec_describe_statement_message(const char *stmt_name)
         */
        pq_beginmessage_reuse(&row_description_buf, 't'); /* parameter description
                                                                                                           * message type */
-       pq_sendint(&row_description_buf, psrc->num_params, 2);
+       pq_sendint16(&row_description_buf, psrc->num_params);
 
        for (i = 0; i < psrc->num_params; i++)
        {
                Oid                     ptype = psrc->param_types[i];
 
-               pq_sendint(&row_description_buf, (int) ptype, 4);
+               pq_sendint32(&row_description_buf, (int) ptype);
        }
        pq_endmessage_reuse(&row_description_buf);
 
@@ -3818,8 +3818,8 @@ PostgresMain(int argc, char *argv[],
                StringInfoData buf;
 
                pq_beginmessage(&buf, 'K');
-               pq_sendint(&buf, (int32) MyProcPid, sizeof(int32));
-               pq_sendint(&buf, (int32) MyCancelKey, sizeof(int32));
+               pq_sendint32(&buf, (int32) MyProcPid);
+               pq_sendint32(&buf, (int32) MyCancelKey);
                pq_endmessage(&buf);
                /* Need not flush since ReadyForQuery will do it. */
        }

diff --git a/src/backend/utils/adt/arrayfuncs.c b/src/backend/utils/adt/arrayfuncs.c
index ca04b13e825abb8e6fc9bcc6a1b3fed3250e04d7..b4c31ef65c2771ae87d98c845a49ee1bb4cbbe2f 100644 (file)
--- a/src/backend/utils/adt/arrayfuncs.c
+++ b/src/backend/utils/adt/arrayfuncs.c
@@ -1590,13 +1590,13 @@ array_send(PG_FUNCTION_ARGS)
        pq_begintypsend(&buf);
 
        /* Send the array header information */
-       pq_sendint(&buf, ndim, 4);
-       pq_sendint(&buf, AARR_HASNULL(v) ? 1 : 0, 4);
-       pq_sendint(&buf, element_type, sizeof(Oid));
+       pq_sendint32(&buf, ndim);
+       pq_sendint32(&buf, AARR_HASNULL(v) ? 1 : 0);
+       pq_sendint32(&buf, element_type);
        for (i = 0; i < ndim; i++)
        {
-               pq_sendint(&buf, dim[i], 4);
-               pq_sendint(&buf, lb[i], 4);
+               pq_sendint32(&buf, dim[i]);
+               pq_sendint32(&buf, lb[i]);
        }
 
        /* Send the array elements using the element's own sendproc */
@@ -1614,14 +1614,14 @@ array_send(PG_FUNCTION_ARGS)
                if (isnull)
                {
                        /* -1 length means a NULL */
-                       pq_sendint(&buf, -1, 4);
+                       pq_sendint32(&buf, -1);
                }
                else
                {
                        bytea      *outputbytes;
 
                        outputbytes = SendFunctionCall(&my_extra->proc, itemvalue);
-                       pq_sendint(&buf, VARSIZE(outputbytes) - VARHDRSZ, 4);
+                       pq_sendint32(&buf, VARSIZE(outputbytes) - VARHDRSZ);
                        pq_sendbytes(&buf, VARDATA(outputbytes),
                                                 VARSIZE(outputbytes) - VARHDRSZ);
                        pfree(outputbytes);

diff --git a/src/backend/utils/adt/date.c b/src/backend/utils/adt/date.c
index 0992bb3fdd024a093374ad923e2151fc05446550..04e737d08085e4fd2c85a67af1c847156a7edf83 100644 (file)
--- a/src/backend/utils/adt/date.c
+++ b/src/backend/utils/adt/date.c
@@ -239,7 +239,7 @@ date_send(PG_FUNCTION_ARGS)
        StringInfoData buf;
 
        pq_begintypsend(&buf);
-       pq_sendint(&buf, date, sizeof(date));
+       pq_sendint32(&buf, date);
        PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }
 
@@ -2049,7 +2049,7 @@ timetz_send(PG_FUNCTION_ARGS)
 
        pq_begintypsend(&buf);
        pq_sendint64(&buf, time->time);
-       pq_sendint(&buf, time->zone, sizeof(time->zone));
+       pq_sendint32(&buf, time->zone);
        PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }
 

diff --git a/src/backend/utils/adt/geo_ops.c b/src/backend/utils/adt/geo_ops.c
index 0348855b11cf6b2d4e4d52fa9fb68ea01af5c25e..e13389a6cc7227d245b5898fe118ca25073878a9 100644 (file)
--- a/src/backend/utils/adt/geo_ops.c
+++ b/src/backend/utils/adt/geo_ops.c
@@ -1433,7 +1433,7 @@ path_send(PG_FUNCTION_ARGS)
 
        pq_begintypsend(&buf);
        pq_sendbyte(&buf, path->closed ? 1 : 0);
-       pq_sendint(&buf, path->npts, sizeof(int32));
+       pq_sendint32(&buf, path->npts);
        for (i = 0; i < path->npts; i++)
        {
                pq_sendfloat8(&buf, path->p[i].x);
@@ -3514,7 +3514,7 @@ poly_send(PG_FUNCTION_ARGS)
        int32           i;
 
        pq_begintypsend(&buf);
-       pq_sendint(&buf, poly->npts, sizeof(int32));
+       pq_sendint32(&buf, poly->npts);
        for (i = 0; i < poly->npts; i++)
        {
                pq_sendfloat8(&buf, poly->p[i].x);

diff --git a/src/backend/utils/adt/int.c b/src/backend/utils/adt/int.c
index 96ef25b900edee55907a30cbff9ea1d5c5ebfcf6..4cd8960b3fca3223e9ee4fad6bd7576591a7ba4d 100644 (file)
--- a/src/backend/utils/adt/int.c
+++ b/src/backend/utils/adt/int.c
@@ -99,7 +99,7 @@ int2send(PG_FUNCTION_ARGS)
        StringInfoData buf;
 
        pq_begintypsend(&buf);
-       pq_sendint(&buf, arg1, sizeof(int16));
+       pq_sendint16(&buf, arg1);
        PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }
 
@@ -304,7 +304,7 @@ int4send(PG_FUNCTION_ARGS)
        StringInfoData buf;
 
        pq_begintypsend(&buf);
-       pq_sendint(&buf, arg1, sizeof(int32));
+       pq_sendint32(&buf, arg1);
        PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }
 

diff --git a/src/backend/utils/adt/jsonb.c b/src/backend/utils/adt/jsonb.c
index 95db89553891a6489fc1b53ac1f023367899aa55..771c05120bb56cd9a70c2fcb51d9f7474ba7b6e1 100644 (file)
--- a/src/backend/utils/adt/jsonb.c
+++ b/src/backend/utils/adt/jsonb.c
@@ -154,7 +154,7 @@ jsonb_send(PG_FUNCTION_ARGS)
        (void) JsonbToCString(jtext, &jb->root, VARSIZE(jb));
 
        pq_begintypsend(&buf);
-       pq_sendint(&buf, version, 1);
+       pq_sendint8(&buf, version);
        pq_sendtext(&buf, jtext->data, jtext->len);
        pfree(jtext->data);
        pfree(jtext);

diff --git a/src/backend/utils/adt/nabstime.c b/src/backend/utils/adt/nabstime.c
index 2c5948052d315f7ed6bf182a504c71d5729a0e4b..2bca39a90cc6fd9019493ceda17ed9ca596236b1 100644 (file)
--- a/src/backend/utils/adt/nabstime.c
+++ b/src/backend/utils/adt/nabstime.c
@@ -315,7 +315,7 @@ abstimesend(PG_FUNCTION_ARGS)
        StringInfoData buf;
 
        pq_begintypsend(&buf);
-       pq_sendint(&buf, time, sizeof(time));
+       pq_sendint32(&buf, time);
        PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }
 
@@ -674,7 +674,7 @@ reltimesend(PG_FUNCTION_ARGS)
        StringInfoData buf;
 
        pq_begintypsend(&buf);
-       pq_sendint(&buf, time, sizeof(time));
+       pq_sendint32(&buf, time);
        PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }
 
@@ -794,9 +794,9 @@ tintervalsend(PG_FUNCTION_ARGS)
        StringInfoData buf;
 
        pq_begintypsend(&buf);
-       pq_sendint(&buf, tinterval->status, sizeof(tinterval->status));
-       pq_sendint(&buf, tinterval->data[0], sizeof(tinterval->data[0]));
-       pq_sendint(&buf, tinterval->data[1], sizeof(tinterval->data[1]));
+       pq_sendint32(&buf, tinterval->status);
+       pq_sendint32(&buf, tinterval->data[0]);
+       pq_sendint32(&buf, tinterval->data[1]);
        PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }
 

diff --git a/src/backend/utils/adt/numeric.c b/src/backend/utils/adt/numeric.c
index 48d95e90501dfda76643043dcdb80b99d2d5d2d7..2cd14f34012aa870970eee7bcbac20a4e6ac60d7 100644 (file)
--- a/src/backend/utils/adt/numeric.c
+++ b/src/backend/utils/adt/numeric.c
@@ -876,12 +876,12 @@ numeric_send(PG_FUNCTION_ARGS)
 
        pq_begintypsend(&buf);
 
-       pq_sendint(&buf, x.ndigits, sizeof(int16));
-       pq_sendint(&buf, x.weight, sizeof(int16));
-       pq_sendint(&buf, x.sign, sizeof(int16));
-       pq_sendint(&buf, x.dscale, sizeof(int16));
+       pq_sendint16(&buf, x.ndigits);
+       pq_sendint16(&buf, x.weight);
+       pq_sendint16(&buf, x.sign);
+       pq_sendint16(&buf, x.dscale);
        for (i = 0; i < x.ndigits; i++)
-               pq_sendint(&buf, x.digits[i], sizeof(NumericDigit));
+               pq_sendint16(&buf, x.digits[i]);
 
        PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }
@@ -3693,7 +3693,7 @@ numeric_avg_serialize(PG_FUNCTION_ARGS)
        pq_sendbytes(&buf, VARDATA_ANY(sumX), VARSIZE_ANY_EXHDR(sumX));
 
        /* maxScale */
-       pq_sendint(&buf, state->maxScale, 4);
+       pq_sendint32(&buf, state->maxScale);
 
        /* maxScaleCount */
        pq_sendint64(&buf, state->maxScaleCount);
@@ -3815,7 +3815,7 @@ numeric_serialize(PG_FUNCTION_ARGS)
        pq_sendbytes(&buf, VARDATA_ANY(sumX2), VARSIZE_ANY_EXHDR(sumX2));
 
        /* maxScale */
-       pq_sendint(&buf, state->maxScale, 4);
+       pq_sendint32(&buf, state->maxScale);
 
        /* maxScaleCount */
        pq_sendint64(&buf, state->maxScaleCount);

diff --git a/src/backend/utils/adt/oid.c b/src/backend/utils/adt/oid.c
index 7baaa1dd4eed57e7a46083e28ee2231b071674a1..87e87fe54d58e8c73744114ff5c60d5f925dcd76 100644 (file)
--- a/src/backend/utils/adt/oid.c
+++ b/src/backend/utils/adt/oid.c
@@ -154,7 +154,7 @@ oidsend(PG_FUNCTION_ARGS)
        StringInfoData buf;
 
        pq_begintypsend(&buf);
-       pq_sendint(&buf, arg1, sizeof(Oid));
+       pq_sendint32(&buf, arg1);
        PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }
 

diff --git a/src/backend/utils/adt/rangetypes.c b/src/backend/utils/adt/rangetypes.c
index d0aa33c010bc31431c7181b90e18d225f8e384e5..e79f0dbfca6aa3687d733742278ae38e1f5ee262 100644 (file)
--- a/src/backend/utils/adt/rangetypes.c
+++ b/src/backend/utils/adt/rangetypes.c
@@ -272,7 +272,7 @@ range_send(PG_FUNCTION_ARGS)
                uint32          bound_len = VARSIZE(bound) - VARHDRSZ;
                char       *bound_data = VARDATA(bound);
 
-               pq_sendint(buf, bound_len, 4);
+               pq_sendint32(buf, bound_len);
                pq_sendbytes(buf, bound_data, bound_len);
        }
 
@@ -283,7 +283,7 @@ range_send(PG_FUNCTION_ARGS)
                uint32          bound_len = VARSIZE(bound) - VARHDRSZ;
                char       *bound_data = VARDATA(bound);
 
-               pq_sendint(buf, bound_len, 4);
+               pq_sendint32(buf, bound_len);
                pq_sendbytes(buf, bound_data, bound_len);
        }
 

diff --git a/src/backend/utils/adt/rowtypes.c b/src/backend/utils/adt/rowtypes.c
index 98fe00ff394c329dadb71e80069626dda1d8d378..9b32db5d0aedffca74a63e2dcece67fc806ea055 100644 (file)
--- a/src/backend/utils/adt/rowtypes.c
+++ b/src/backend/utils/adt/rowtypes.c
@@ -718,7 +718,7 @@ record_send(PG_FUNCTION_ARGS)
                if (!TupleDescAttr(tupdesc, i)->attisdropped)
                        validcols++;
        }
-       pq_sendint(&buf, validcols, 4);
+       pq_sendint32(&buf, validcols);
 
        for (i = 0; i < ncolumns; i++)
        {
@@ -732,12 +732,12 @@ record_send(PG_FUNCTION_ARGS)
                if (att->attisdropped)
                        continue;
 
-               pq_sendint(&buf, column_type, sizeof(Oid));
+               pq_sendint32(&buf, column_type);
 
                if (nulls[i])
                {
                        /* emit -1 data length to signify a NULL */
-                       pq_sendint(&buf, -1, 4);
+                       pq_sendint32(&buf, -1);
                        continue;
                }
 
@@ -756,7 +756,7 @@ record_send(PG_FUNCTION_ARGS)
 
                attr = values[i];
                outputbytes = SendFunctionCall(&column_info->proc, attr);
-               pq_sendint(&buf, VARSIZE(outputbytes) - VARHDRSZ, 4);
+               pq_sendint32(&buf, VARSIZE(outputbytes) - VARHDRSZ);
                pq_sendbytes(&buf, VARDATA(outputbytes),
                                         VARSIZE(outputbytes) - VARHDRSZ);
        }

diff --git a/src/backend/utils/adt/tid.c b/src/backend/utils/adt/tid.c
index 083f7d60a7bcf9b075ea84543e15142d831d1f1b..854097dd583e62512a2ea4dac654ce9e9e00f059 100644 (file)
--- a/src/backend/utils/adt/tid.c
+++ b/src/backend/utils/adt/tid.c
@@ -149,10 +149,8 @@ tidsend(PG_FUNCTION_ARGS)
        StringInfoData buf;
 
        pq_begintypsend(&buf);
-       pq_sendint(&buf, ItemPointerGetBlockNumberNoCheck(itemPtr),
-                          sizeof(BlockNumber));
-       pq_sendint(&buf, ItemPointerGetOffsetNumberNoCheck(itemPtr),
-                          sizeof(OffsetNumber));
+       pq_sendint32(&buf, ItemPointerGetBlockNumberNoCheck(itemPtr));
+       pq_sendint16(&buf, ItemPointerGetOffsetNumberNoCheck(itemPtr));
        PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }
 

diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c
index b11d452fc8a024a9dcfab74e2ace6f5985637d5c..5797aaad34c0cc1fb477b0c3d147e7d67fec2354 100644 (file)
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -1009,8 +1009,8 @@ interval_send(PG_FUNCTION_ARGS)
 
        pq_begintypsend(&buf);
        pq_sendint64(&buf, interval->time);
-       pq_sendint(&buf, interval->day, sizeof(interval->day));
-       pq_sendint(&buf, interval->month, sizeof(interval->month));
+       pq_sendint32(&buf, interval->day);
+       pq_sendint32(&buf, interval->month);
        PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }
 

diff --git a/src/backend/utils/adt/tsquery.c b/src/backend/utils/adt/tsquery.c
index fdb041971e5228538b5edda16339abef378a9b77..5cdfe4d732276226f2f0a4d7adb02cf93394a258 100644 (file)
--- a/src/backend/utils/adt/tsquery.c
+++ b/src/backend/utils/adt/tsquery.c
@@ -952,23 +952,22 @@ tsquerysend(PG_FUNCTION_ARGS)
 
        pq_begintypsend(&buf);
 
-       pq_sendint(&buf, query->size, sizeof(uint32));
+       pq_sendint32(&buf, query->size);
        for (i = 0; i < query->size; i++)
        {
-               pq_sendint(&buf, item->type, sizeof(item->type));
+               pq_sendint8(&buf, item->type);
 
                switch (item->type)
                {
                        case QI_VAL:
-                               pq_sendint(&buf, item->qoperand.weight, sizeof(uint8));
-                               pq_sendint(&buf, item->qoperand.prefix, sizeof(uint8));
+                               pq_sendint8(&buf, item->qoperand.weight);
+                               pq_sendint8(&buf, item->qoperand.prefix);
                                pq_sendstring(&buf, GETOPERAND(query) + item->qoperand.distance);
                                break;
                        case QI_OPR:
-                               pq_sendint(&buf, item->qoperator.oper, sizeof(item->qoperator.oper));
+                               pq_sendint8(&buf, item->qoperator.oper);
                                if (item->qoperator.oper == OP_PHRASE)
-                                       pq_sendint(&buf, item->qoperator.distance,
-                                                          sizeof(item->qoperator.distance));
+                                       pq_sendint16(&buf, item->qoperator.distance);
                                break;
                        default:
                                elog(ERROR, "unrecognized tsquery node type: %d", item->type);

diff --git a/src/backend/utils/adt/tsvector.c b/src/backend/utils/adt/tsvector.c
index 6f66c1f58ce35fe1455b9448d0d4110b50c1c221..b0a9217d1e3c97215a933d18b0b535f0befeafd0 100644 (file)
--- a/src/backend/utils/adt/tsvector.c
+++ b/src/backend/utils/adt/tsvector.c
@@ -410,7 +410,7 @@ tsvectorsend(PG_FUNCTION_ARGS)
 
        pq_begintypsend(&buf);
 
-       pq_sendint(&buf, vec->size, sizeof(int32));
+       pq_sendint32(&buf, vec->size);
        for (i = 0; i < vec->size; i++)
        {
                uint16          npos;
@@ -423,14 +423,14 @@ tsvectorsend(PG_FUNCTION_ARGS)
                pq_sendbyte(&buf, '\0');
 
                npos = POSDATALEN(vec, weptr);
-               pq_sendint(&buf, npos, sizeof(uint16));
+               pq_sendint16(&buf, npos);
 
                if (npos > 0)
                {
                        WordEntryPos *wepptr = POSDATAPTR(vec, weptr);
 
                        for (j = 0; j < npos; j++)
-                               pq_sendint(&buf, wepptr[j], sizeof(WordEntryPos));
+                               pq_sendint16(&buf, wepptr[j]);
                }
                weptr++;
        }

diff --git a/src/backend/utils/adt/txid.c b/src/backend/utils/adt/txid.c
index 1e38ca2aa5e68f2da5b77f0538fd5b4faa5e7a36..9d312edf04f0f932e9c812823c06453627abfe13 100644 (file)
--- a/src/backend/utils/adt/txid.c
+++ b/src/backend/utils/adt/txid.c
@@ -640,7 +640,7 @@ txid_snapshot_send(PG_FUNCTION_ARGS)
        uint32          i;
 
        pq_begintypsend(&buf);
-       pq_sendint(&buf, snap->nxip, 4);
+       pq_sendint32(&buf, snap->nxip);
        pq_sendint64(&buf, snap->xmin);
        pq_sendint64(&buf, snap->xmax);
        for (i = 0; i < snap->nxip; i++)

diff --git a/src/backend/utils/adt/varbit.c b/src/backend/utils/adt/varbit.c
index 0cf1c6f6d603087dacfa77376870781a21790566..478fab9bfce060b713e9226dfd8f7ff7674fc595 100644 (file)
--- a/src/backend/utils/adt/varbit.c
+++ b/src/backend/utils/adt/varbit.c
@@ -665,7 +665,7 @@ varbit_send(PG_FUNCTION_ARGS)
        StringInfoData buf;
 
        pq_begintypsend(&buf);
-       pq_sendint(&buf, VARBITLEN(s), sizeof(int32));
+       pq_sendint32(&buf, VARBITLEN(s));
        pq_sendbytes(&buf, (char *) VARBITS(s), VARBITBYTES(s));
        PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }

diff --git a/src/backend/utils/adt/xid.c b/src/backend/utils/adt/xid.c
index 2051709fdef2cdb1f05a0c45c256f89a3cf9e445..67c32ac61937a8193b8343052fc7d8e16d533d01 100644 (file)
--- a/src/backend/utils/adt/xid.c
+++ b/src/backend/utils/adt/xid.c
@@ -68,7 +68,7 @@ xidsend(PG_FUNCTION_ARGS)
        StringInfoData buf;
 
        pq_begintypsend(&buf);
-       pq_sendint(&buf, arg1, sizeof(arg1));
+       pq_sendint32(&buf, arg1);
        PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }
 
@@ -196,7 +196,7 @@ cidsend(PG_FUNCTION_ARGS)
        StringInfoData buf;
 
        pq_begintypsend(&buf);
-       pq_sendint(&buf, arg1, sizeof(arg1));
+       pq_sendint32(&buf, arg1);
        PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }