database/postgres
database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-04-18 13:44:19 +03:00
Code

Use PRI?64 instead of "ll?" in format strings (continued).

Browse Source 
Continuation of work started in commit 15a79c73, after initial trial.

Author: Thomas Munro <thomas.munro@gmail.com>
Discussion: https://postgr.es/m/b936d2fb-590d-49c3-a615-92c3a88c6c19%40eisentraut.org
This commit is contained in:
Peter Eisentraut 2025-03-29 10:30:08 +01:00
parent a0a4601765
commit a0ed19e0a9
54 changed files with 302 additions and 311 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
contrib/file_fdw/file_fdw.c
View File

@ -798,8 +798,8 @@ retry:
cstate->num_errors > cstate->opts.reject_limit) cstate->num_errors > cstate->opts.reject_limit)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("skipped more than REJECT_LIMIT (%lld) rows due to data type incompatibility", errmsg("skipped more than REJECT_LIMIT (%" PRId64 ") rows due to data type incompatibility",
(long long) cstate->opts.reject_limit))); cstate->opts.reject_limit)));
/* Repeat NextCopyFrom() until no soft error occurs */ /* Repeat NextCopyFrom() until no soft error occurs */
goto retry; goto retry;
@ -855,10 +855,10 @@ fileEndForeignScan(ForeignScanState *node)
festate->cstate->num_errors > 0 && festate->cstate->num_errors > 0 &&
festate->cstate->opts.log_verbosity >= COPY_LOG_VERBOSITY_DEFAULT) festate->cstate->opts.log_verbosity >= COPY_LOG_VERBOSITY_DEFAULT)
ereport(NOTICE, ereport(NOTICE,
errmsg_plural("%llu row was skipped due to data type incompatibility", errmsg_plural("%" PRIu64 " row was skipped due to data type incompatibility",
"%llu rows were skipped due to data type incompatibility", "%" PRIu64 " rows were skipped due to data type incompatibility",
(unsigned long long) festate->cstate->num_errors, festate->cstate->num_errors,
(unsigned long long) festate->cstate->num_errors)); festate->cstate->num_errors));
EndCopyFrom(festate->cstate); EndCopyFrom(festate->cstate);
} }
@ -1319,10 +1319,10 @@ file_acquire_sample_rows(Relation onerel, int elevel,
cstate->num_errors > 0 && cstate->num_errors > 0 &&
cstate->opts.log_verbosity >= COPY_LOG_VERBOSITY_DEFAULT) cstate->opts.log_verbosity >= COPY_LOG_VERBOSITY_DEFAULT)
ereport(NOTICE, ereport(NOTICE,
errmsg_plural("%llu row was skipped due to data type incompatibility", errmsg_plural("%" PRIu64 " row was skipped due to data type incompatibility",
"%llu rows were skipped due to data type incompatibility", "%" PRIu64 " rows were skipped due to data type incompatibility",
(unsigned long long) cstate->num_errors, cstate->num_errors,
(unsigned long long) cstate->num_errors)); cstate->num_errors));
EndCopyFrom(cstate); EndCopyFrom(cstate);

6
contrib/pageinspect/btreefuncs.c
View File

@ -206,14 +206,12 @@ check_relation_block_range(Relation rel, int64 blkno)
if (blkno < 0 || blkno > MaxBlockNumber) if (blkno < 0 || blkno > MaxBlockNumber)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("invalid block number %lld", errmsg("invalid block number %" PRId64, blkno)));
(long long) blkno)));
if ((BlockNumber) (blkno) >= RelationGetNumberOfBlocks(rel)) if ((BlockNumber) (blkno) >= RelationGetNumberOfBlocks(rel))
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("block number %lld is out of range", errmsg("block number %" PRId64 " is out of range", blkno)));
(long long) blkno)));
} }
/* ----------------------------------------------- /* -----------------------------------------------

4
contrib/pageinspect/hashfuncs.c
View File

@ -436,8 +436,8 @@ hash_bitmap_info(PG_FUNCTION_ARGS)
if (ovflblkno >= RelationGetNumberOfBlocks(indexRel)) if (ovflblkno >= RelationGetNumberOfBlocks(indexRel))
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("block number %lld is out of range for relation \"%s\"", errmsg("block number %" PRId64 " is out of range for relation \"%s\"",
(long long int) ovflblkno, RelationGetRelationName(indexRel)))); ovflblkno, RelationGetRelationName(indexRel))));
/* Read the metapage so we can determine which bitmap page to use */ /* Read the metapage so we can determine which bitmap page to use */
metabuf = _hash_getbuf(indexRel, HASH_METAPAGE, HASH_READ, LH_META_PAGE); metabuf = _hash_getbuf(indexRel, HASH_METAPAGE, HASH_READ, LH_META_PAGE);

8
contrib/pg_prewarm/pg_prewarm.c
View File

@ -129,8 +129,8 @@ pg_prewarm(PG_FUNCTION_ARGS)
if (first_block < 0 || first_block >= nblocks) if (first_block < 0 || first_block >= nblocks)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("starting block number must be between 0 and %lld", errmsg("starting block number must be between 0 and %" PRId64,
(long long) (nblocks - 1)))); (nblocks - 1))));
} }
if (PG_ARGISNULL(4)) if (PG_ARGISNULL(4))
last_block = nblocks - 1; last_block = nblocks - 1;
@ -140,8 +140,8 @@ pg_prewarm(PG_FUNCTION_ARGS)
if (last_block < 0 || last_block >= nblocks) if (last_block < 0 || last_block >= nblocks)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("ending block number must be between 0 and %lld", errmsg("ending block number must be between 0 and %" PRId64,
(long long) (nblocks - 1)))); (nblocks - 1))));
} }
/* Now we're ready to do the real work. */ /* Now we're ready to do the real work. */

7
src/backend/access/brin/brin.c
View File

@ -1400,8 +1400,7 @@ brin_summarize_range(PG_FUNCTION_ARGS)
if (heapBlk64 > BRIN_ALL_BLOCKRANGES || heapBlk64 < 0) if (heapBlk64 > BRIN_ALL_BLOCKRANGES || heapBlk64 < 0)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
errmsg("block number out of range: %lld", errmsg("block number out of range: %" PRId64, heapBlk64)));
(long long) heapBlk64)));
heapBlk = (BlockNumber) heapBlk64; heapBlk = (BlockNumber) heapBlk64;
/* /*
@ -1508,8 +1507,8 @@ brin_desummarize_range(PG_FUNCTION_ARGS)
if (heapBlk64 > MaxBlockNumber || heapBlk64 < 0) if (heapBlk64 > MaxBlockNumber || heapBlk64 < 0)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
errmsg("block number out of range: %lld", errmsg("block number out of range: %" PRId64,
(long long) heapBlk64))); heapBlk64)));
heapBlk = (BlockNumber) heapBlk64; heapBlk = (BlockNumber) heapBlk64;
/* /*

44
src/backend/access/heap/vacuumlazy.c
View File

@ -1020,14 +1020,14 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
orig_rel_pages, orig_rel_pages,
vacrel->eager_scanned_pages); vacrel->eager_scanned_pages);
appendStringInfo(&buf, appendStringInfo(&buf,
_("tuples: %lld removed, %lld remain, %lld are dead but not yet removable\n"), _("tuples: %" PRId64 " removed, %" PRId64 " remain, %" PRId64 " are dead but not yet removable\n"),
(long long) vacrel->tuples_deleted, vacrel->tuples_deleted,
(long long) vacrel->new_rel_tuples, (int64) vacrel->new_rel_tuples,
(long long) vacrel->recently_dead_tuples); vacrel->recently_dead_tuples);
if (vacrel->missed_dead_tuples > 0) if (vacrel->missed_dead_tuples > 0)
appendStringInfo(&buf, appendStringInfo(&buf,
_("tuples missed: %lld dead from %u pages not removed due to cleanup lock contention\n"), _("tuples missed: %" PRId64 " dead from %u pages not removed due to cleanup lock contention\n"),
(long long) vacrel->missed_dead_tuples, vacrel->missed_dead_tuples,
vacrel->missed_dead_pages); vacrel->missed_dead_pages);
diff = (int32) (ReadNextTransactionId() - diff = (int32) (ReadNextTransactionId() -
vacrel->cutoffs.OldestXmin); vacrel->cutoffs.OldestXmin);
@ -1050,12 +1050,12 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
_("new relminmxid: %u, which is %d MXIDs ahead of previous value\n"), _("new relminmxid: %u, which is %d MXIDs ahead of previous value\n"),
vacrel->NewRelminMxid, diff); vacrel->NewRelminMxid, diff);
} }
appendStringInfo(&buf, _("frozen: %u pages from table (%.2f%% of total) had %lld tuples frozen\n"), appendStringInfo(&buf, _("frozen: %u pages from table (%.2f%% of total) had %" PRId64 " tuples frozen\n"),
vacrel->new_frozen_tuple_pages, vacrel->new_frozen_tuple_pages,
orig_rel_pages == 0 ? 100.0 : orig_rel_pages == 0 ? 100.0 :
100.0 * vacrel->new_frozen_tuple_pages / 100.0 * vacrel->new_frozen_tuple_pages /
orig_rel_pages, orig_rel_pages,
(long long) vacrel->tuples_frozen); vacrel->tuples_frozen);
appendStringInfo(&buf, appendStringInfo(&buf,
_("visibility map: %u pages set all-visible, %u pages set all-frozen (%u were all-visible)\n"), _("visibility map: %u pages set all-visible, %u pages set all-frozen (%u were all-visible)\n"),
@ -1070,7 +1070,7 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
else else
appendStringInfoString(&buf, _("index scan needed: ")); appendStringInfoString(&buf, _("index scan needed: "));
msgfmt = _("%u pages from table (%.2f%% of total) had %lld dead item identifiers removed\n"); msgfmt = _("%u pages from table (%.2f%% of total) had %" PRId64 " dead item identifiers removed\n");
} }
else else
{ {
@ -1079,13 +1079,13 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
else else
appendStringInfoString(&buf, _("index scan bypassed by failsafe: ")); appendStringInfoString(&buf, _("index scan bypassed by failsafe: "));
msgfmt = _("%u pages from table (%.2f%% of total) have %lld dead item identifiers\n"); msgfmt = _("%u pages from table (%.2f%% of total) have %" PRId64 " dead item identifiers\n");
} }
appendStringInfo(&buf, msgfmt, appendStringInfo(&buf, msgfmt,
vacrel->lpdead_item_pages, vacrel->lpdead_item_pages,
orig_rel_pages == 0 ? 100.0 : orig_rel_pages == 0 ? 100.0 :
100.0 * vacrel->lpdead_item_pages / orig_rel_pages, 100.0 * vacrel->lpdead_item_pages / orig_rel_pages,
(long long) vacrel->lpdead_items); vacrel->lpdead_items);
for (int i = 0; i < vacrel->nindexes; i++) for (int i = 0; i < vacrel->nindexes; i++)
{ {
IndexBulkDeleteResult *istat = vacrel->indstats[i]; IndexBulkDeleteResult *istat = vacrel->indstats[i];
@ -1130,16 +1130,16 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
appendStringInfo(&buf, _("avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n"), appendStringInfo(&buf, _("avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n"),
read_rate, write_rate); read_rate, write_rate);
appendStringInfo(&buf, appendStringInfo(&buf,
_("buffer usage: %lld hits, %lld reads, %lld dirtied\n"), _("buffer usage: %" PRId64 " hits, %" PRId64 " reads, %" PRId64 " dirtied\n"),
(long long) total_blks_hit, total_blks_hit,
(long long) total_blks_read, total_blks_read,
(long long) total_blks_dirtied); total_blks_dirtied);
appendStringInfo(&buf, appendStringInfo(&buf,
_("WAL usage: %lld records, %lld full page images, %llu bytes, %lld buffers full\n"), _("WAL usage: %" PRId64 " records, %" PRId64 " full page images, %" PRIu64 " bytes, %" PRId64 " buffers full\n"),
(long long) walusage.wal_records, walusage.wal_records,
(long long) walusage.wal_fpi, walusage.wal_fpi,
(unsigned long long) walusage.wal_bytes, walusage.wal_bytes,
(long long) walusage.wal_buffers_full); walusage.wal_buffers_full);
appendStringInfo(&buf, _("system usage: %s"), pg_rusage_show(&ru0)); appendStringInfo(&buf, _("system usage: %s"), pg_rusage_show(&ru0));
ereport(verbose ? INFO : LOG, ereport(verbose ? INFO : LOG,
@ -2802,8 +2802,8 @@ lazy_vacuum_heap_rel(LVRelState *vacrel)
vacuumed_pages == vacrel->lpdead_item_pages)); vacuumed_pages == vacrel->lpdead_item_pages));
ereport(DEBUG2, ereport(DEBUG2,
(errmsg("table \"%s\": removed %lld dead item identifiers in %u pages", (errmsg("table \"%s\": removed %" PRId64 " dead item identifiers in %u pages",
vacrel->relname, (long long) vacrel->dead_items_info->num_items, vacrel->relname, vacrel->dead_items_info->num_items,
vacuumed_pages))); vacuumed_pages)));
/* Revert to the previous phase information for error traceback */ /* Revert to the previous phase information for error traceback */

6
src/backend/access/rmgrdesc/clogdesc.c
View File

@ -28,15 +28,15 @@ clog_desc(StringInfo buf, XLogReaderState *record)
int64 pageno; int64 pageno;
memcpy(&pageno, rec, sizeof(pageno)); memcpy(&pageno, rec, sizeof(pageno));
appendStringInfo(buf, "page %lld", (long long) pageno); appendStringInfo(buf, "page %" PRId64, pageno);
} }
else if (info == CLOG_TRUNCATE) else if (info == CLOG_TRUNCATE)
{ {
xl_clog_truncate xlrec; xl_clog_truncate xlrec;
memcpy(&xlrec, rec, sizeof(xl_clog_truncate)); memcpy(&xlrec, rec, sizeof(xl_clog_truncate));
appendStringInfo(buf, "page %lld; oldestXact %u", appendStringInfo(buf, "page %" PRId64 "; oldestXact %u",
(long long) xlrec.pageno, xlrec.oldestXact); xlrec.pageno, xlrec.oldestXact);
} }
} }

6
src/backend/access/rmgrdesc/committsdesc.c
View File

@ -28,14 +28,14 @@ commit_ts_desc(StringInfo buf, XLogReaderState *record)
int64 pageno; int64 pageno;
memcpy(&pageno, rec, sizeof(pageno)); memcpy(&pageno, rec, sizeof(pageno));
appendStringInfo(buf, "%lld", (long long) pageno); appendStringInfo(buf, "%" PRId64, pageno);
} }
else if (info == COMMIT_TS_TRUNCATE) else if (info == COMMIT_TS_TRUNCATE)
{ {
xl_commit_ts_truncate *trunc = (xl_commit_ts_truncate *) rec; xl_commit_ts_truncate *trunc = (xl_commit_ts_truncate *) rec;
appendStringInfo(buf, "pageno %lld, oldestXid %u", appendStringInfo(buf, "pageno %" PRId64 ", oldestXid %u",
(long long) trunc->pageno, trunc->oldestXid); trunc->pageno, trunc->oldestXid);
} }
} }

2
src/backend/access/rmgrdesc/mxactdesc.c
View File

@ -58,7 +58,7 @@ multixact_desc(StringInfo buf, XLogReaderState *record)
int64 pageno; int64 pageno;
memcpy(&pageno, rec, sizeof(pageno)); memcpy(&pageno, rec, sizeof(pageno));
appendStringInfo(buf, "%lld", (long long) pageno); appendStringInfo(buf, "%" PRId64, pageno);
} }
else if (info == XLOG_MULTIXACT_CREATE_ID) else if (info == XLOG_MULTIXACT_CREATE_ID)
{ {

4
src/backend/access/rmgrdesc/xactdesc.c
View File

@ -320,10 +320,10 @@ xact_desc_stats(StringInfo buf, const char *label,
uint64 objid = uint64 objid =
((uint64) dropped_stats[i].objid_hi) << 32 | dropped_stats[i].objid_lo; ((uint64) dropped_stats[i].objid_hi) << 32 | dropped_stats[i].objid_lo;
appendStringInfo(buf, " %d/%u/%llu", appendStringInfo(buf, " %d/%u/%" PRIu64,
dropped_stats[i].kind, dropped_stats[i].kind,
dropped_stats[i].dboid, dropped_stats[i].dboid,
(unsigned long long) objid); objid);
} }
} }
} }

28
src/backend/access/transam/multixact.c
View File

@ -3058,8 +3058,8 @@ PerformMembersTruncation(MultiXactOffset oldestOffset, MultiXactOffset newOldest
*/ */
while (segment != endsegment) while (segment != endsegment)
{ {
elog(DEBUG2, "truncating multixact members segment %llx", elog(DEBUG2, "truncating multixact members segment %" PRIx64,
(unsigned long long) segment); segment);
SlruDeleteSegment(MultiXactMemberCtl, segment); SlruDeleteSegment(MultiXactMemberCtl, segment);
/* move to next segment, handling wraparound correctly */ /* move to next segment, handling wraparound correctly */
@ -3210,14 +3210,14 @@ TruncateMultiXact(MultiXactId newOldestMulti, Oid newOldestMultiDB)
} }
elog(DEBUG1, "performing multixact truncation: " elog(DEBUG1, "performing multixact truncation: "
"offsets [%u, %u), offsets segments [%llx, %llx), " "offsets [%u, %u), offsets segments [%" PRIx64 ", %" PRIx64 "), "
"members [%u, %u), members segments [%llx, %llx)", "members [%u, %u), members segments [%" PRIx64 ", %" PRIx64 ")",
oldestMulti, newOldestMulti, oldestMulti, newOldestMulti,
(unsigned long long) MultiXactIdToOffsetSegment(oldestMulti), MultiXactIdToOffsetSegment(oldestMulti),
(unsigned long long) MultiXactIdToOffsetSegment(newOldestMulti), MultiXactIdToOffsetSegment(newOldestMulti),
oldestOffset, newOldestOffset, oldestOffset, newOldestOffset,
(unsigned long long) MXOffsetToMemberSegment(oldestOffset), MXOffsetToMemberSegment(oldestOffset),
(unsigned long long) MXOffsetToMemberSegment(newOldestOffset)); MXOffsetToMemberSegment(newOldestOffset));
/* /*
* Do truncation, and the WAL logging of the truncation, in a critical * Do truncation, and the WAL logging of the truncation, in a critical
@ -3470,14 +3470,14 @@ multixact_redo(XLogReaderState *record)
SizeOfMultiXactTruncate); SizeOfMultiXactTruncate);
elog(DEBUG1, "replaying multixact truncation: " elog(DEBUG1, "replaying multixact truncation: "
"offsets [%u, %u), offsets segments [%llx, %llx), " "offsets [%u, %u), offsets segments [%" PRIx64 ", %" PRIx64 "), "
"members [%u, %u), members segments [%llx, %llx)", "members [%u, %u), members segments [%" PRIx64 ", %" PRIx64 ")",
xlrec.startTruncOff, xlrec.endTruncOff, xlrec.startTruncOff, xlrec.endTruncOff,
(unsigned long long) MultiXactIdToOffsetSegment(xlrec.startTruncOff), MultiXactIdToOffsetSegment(xlrec.startTruncOff),
(unsigned long long) MultiXactIdToOffsetSegment(xlrec.endTruncOff), MultiXactIdToOffsetSegment(xlrec.endTruncOff),
xlrec.startTruncMemb, xlrec.endTruncMemb, xlrec.startTruncMemb, xlrec.endTruncMemb,
(unsigned long long) MXOffsetToMemberSegment(xlrec.startTruncMemb), MXOffsetToMemberSegment(xlrec.startTruncMemb),
(unsigned long long) MXOffsetToMemberSegment(xlrec.endTruncMemb)); MXOffsetToMemberSegment(xlrec.endTruncMemb));
/* should not be required, but more than cheap enough */ /* should not be required, but more than cheap enough */
LWLockAcquire(MultiXactTruncationLock, LW_EXCLUSIVE); LWLockAcquire(MultiXactTruncationLock, LW_EXCLUSIVE);

3
src/backend/access/transam/slru.c
View File

@ -100,8 +100,7 @@ SlruFileName(SlruCtl ctl, char *path, int64 segno)
* that in the future we can't decrease SLRU_PAGES_PER_SEGMENT easily. * that in the future we can't decrease SLRU_PAGES_PER_SEGMENT easily.
*/ */
Assert(segno >= 0 && segno <= INT64CONST(0xFFFFFFFFFFFFFFF)); Assert(segno >= 0 && segno <= INT64CONST(0xFFFFFFFFFFFFFFF));
return snprintf(path, MAXPGPATH, "%s/%015llX", ctl->Dir, return snprintf(path, MAXPGPATH, "%s/%015" PRIX64, ctl->Dir, segno);
(long long) segno);
} }
else else
{ {

8
src/backend/access/transam/xloginsert.c
View File

@ -869,8 +869,8 @@ XLogRecordAssemble(RmgrId rmid, uint8 info,
if (mainrdata_len > PG_UINT32_MAX) if (mainrdata_len > PG_UINT32_MAX)
ereport(ERROR, ereport(ERROR,
(errmsg_internal("too much WAL data"), (errmsg_internal("too much WAL data"),
errdetail_internal("Main data length is %llu bytes for a maximum of %u bytes.", errdetail_internal("Main data length is %" PRIu64 " bytes for a maximum of %u bytes.",
(unsigned long long) mainrdata_len, mainrdata_len,
PG_UINT32_MAX))); PG_UINT32_MAX)));
mainrdata_len_4b = (uint32) mainrdata_len; mainrdata_len_4b = (uint32) mainrdata_len;
@ -915,8 +915,8 @@ XLogRecordAssemble(RmgrId rmid, uint8 info,
if (total_len > XLogRecordMaxSize) if (total_len > XLogRecordMaxSize)
ereport(ERROR, ereport(ERROR,
(errmsg_internal("oversized WAL record"), (errmsg_internal("oversized WAL record"),
errdetail_internal("WAL record would be %llu bytes (of maximum %u bytes); rmid %u flags %u.", errdetail_internal("WAL record would be %" PRIu64 " bytes (of maximum %u bytes); rmid %u flags %u.",
(unsigned long long) total_len, XLogRecordMaxSize, rmid, info))); total_len, XLogRecordMaxSize, rmid, info)));
/* /*
* Fill in the fields in the record header. Prev-link is filled in later, * Fill in the fields in the record header. Prev-link is filled in later,

6
src/backend/access/transam/xlogreader.c
View File

@ -1272,9 +1272,9 @@ XLogReaderValidatePageHeader(XLogReaderState *state, XLogRecPtr recptr,
longhdr->xlp_sysid != state->system_identifier) longhdr->xlp_sysid != state->system_identifier)
{ {
report_invalid_record(state, report_invalid_record(state,
"WAL file is from different database system: WAL file database system identifier is %llu, pg_control database system identifier is %llu", "WAL file is from different database system: WAL file database system identifier is %" PRIu64 ", pg_control database system identifier is %" PRIu64,
(unsigned long long) longhdr->xlp_sysid, longhdr->xlp_sysid,
(unsigned long long) state->system_identifier); state->system_identifier);
return false; return false;
} }
else if (longhdr->xlp_seg_size != state->segcxt.ws_segsize) else if (longhdr->xlp_seg_size != state->segcxt.ws_segsize)

6
src/backend/backup/basebackup_incremental.c
View File

@ -949,9 +949,9 @@ manifest_process_system_identifier(JsonManifestParseContext *context,
if (manifest_system_identifier != system_identifier) if (manifest_system_identifier != system_identifier)
context->error_cb(context, context->error_cb(context,
"system identifier in backup manifest is %llu, but database system identifier is %llu", "system identifier in backup manifest is %" PRIu64 ", but database system identifier is %" PRIu64,
(unsigned long long) manifest_system_identifier, manifest_system_identifier,
(unsigned long long) system_identifier); system_identifier);
} }
/* /*

2
src/backend/backup/walsummaryfuncs.c
View File

@ -92,7 +92,7 @@ pg_wal_summary_contents(PG_FUNCTION_ARGS)
if (raw_tli < 1 || raw_tli > PG_INT32_MAX) if (raw_tli < 1 || raw_tli > PG_INT32_MAX)
ereport(ERROR, ereport(ERROR,
errcode(ERRCODE_INVALID_PARAMETER_VALUE), errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("invalid timeline %lld", (long long) raw_tli)); errmsg("invalid timeline %" PRId64, raw_tli));
/* Prepare to read the specified WAL summary file. */ /* Prepare to read the specified WAL summary file. */
ws.tli = (TimeLineID) raw_tli; ws.tli = (TimeLineID) raw_tli;

12
src/backend/catalog/catalog.c
View File

@ -474,10 +474,10 @@ GetNewOidWithIndex(Relation relation, Oid indexId, AttrNumber oidcolumn)
ereport(LOG, ereport(LOG,
(errmsg("still searching for an unused OID in relation \"%s\"", (errmsg("still searching for an unused OID in relation \"%s\"",
RelationGetRelationName(relation)), RelationGetRelationName(relation)),
errdetail_plural("OID candidates have been checked %llu time, but no unused OID has been found yet.", errdetail_plural("OID candidates have been checked %" PRIu64 " time, but no unused OID has been found yet.",
"OID candidates have been checked %llu times, but no unused OID has been found yet.", "OID candidates have been checked %" PRIu64 " times, but no unused OID has been found yet.",
retries, retries,
(unsigned long long) retries))); retries)));
/* /*
* Double the number of retries to do before logging next until it * Double the number of retries to do before logging next until it
@ -499,10 +499,10 @@ GetNewOidWithIndex(Relation relation, Oid indexId, AttrNumber oidcolumn)
if (retries > GETNEWOID_LOG_THRESHOLD) if (retries > GETNEWOID_LOG_THRESHOLD)
{ {
ereport(LOG, ereport(LOG,
(errmsg_plural("new OID has been assigned in relation \"%s\" after %llu retry", (errmsg_plural("new OID has been assigned in relation \"%s\" after %" PRIu64 " retry",
"new OID has been assigned in relation \"%s\" after %llu retries", "new OID has been assigned in relation \"%s\" after %" PRIu64 " retries",
retries, retries,
RelationGetRelationName(relation), (unsigned long long) retries))); RelationGetRelationName(relation), retries)));
} }
return newOid; return newOid;

18
src/backend/commands/analyze.c
View File

@ -827,16 +827,16 @@ do_analyze_rel(Relation onerel, VacuumParams *params,
} }
appendStringInfo(&buf, _("avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n"), appendStringInfo(&buf, _("avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n"),
read_rate, write_rate); read_rate, write_rate);
appendStringInfo(&buf, _("buffer usage: %lld hits, %lld reads, %lld dirtied\n"), appendStringInfo(&buf, _("buffer usage: %" PRId64 " hits, %" PRId64 " reads, %" PRId64 " dirtied\n"),
(long long) total_blks_hit, total_blks_hit,
(long long) total_blks_read, total_blks_read,
(long long) total_blks_dirtied); total_blks_dirtied);
appendStringInfo(&buf, appendStringInfo(&buf,
_("WAL usage: %lld records, %lld full page images, %llu bytes, %lld buffers full\n"), _("WAL usage: %" PRId64 " records, %" PRId64 " full page images, %" PRIu64 " bytes, %" PRId64 " buffers full\n"),
(long long) walusage.wal_records, walusage.wal_records,
(long long) walusage.wal_fpi, walusage.wal_fpi,
(unsigned long long) walusage.wal_bytes, walusage.wal_bytes,
(long long) walusage.wal_buffers_full); walusage.wal_buffers_full);
appendStringInfo(&buf, _("system usage: %s"), pg_rusage_show(&ru0)); appendStringInfo(&buf, _("system usage: %s"), pg_rusage_show(&ru0));
ereport(verbose ? INFO : LOG, ereport(verbose ? INFO : LOG,

4
src/backend/commands/copy.c
View File

@ -443,8 +443,8 @@ defGetCopyRejectLimitOption(DefElem *def)
if (reject_limit <= 0) if (reject_limit <= 0)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("REJECT_LIMIT (%lld) must be greater than zero", errmsg("REJECT_LIMIT (%" PRId64 ") must be greater than zero",
(long long) reject_limit))); reject_limit)));
return reject_limit; return reject_limit;
} }

36
src/backend/commands/copyfrom.c
View File

@ -265,14 +265,14 @@ CopyFromErrorCallback(void *arg)
{ {
/* can't usefully display the data */ /* can't usefully display the data */
if (cstate->cur_attname) if (cstate->cur_attname)
errcontext("COPY %s, line %llu, column %s", errcontext("COPY %s, line %" PRIu64 ", column %s",
cstate->cur_relname, cstate->cur_relname,
(unsigned long long) cstate->cur_lineno, cstate->cur_lineno,
cstate->cur_attname); cstate->cur_attname);
else else
errcontext("COPY %s, line %llu", errcontext("COPY %s, line %" PRIu64,
cstate->cur_relname, cstate->cur_relname,
(unsigned long long) cstate->cur_lineno); cstate->cur_lineno);
} }
else else
{ {
@ -282,9 +282,9 @@ CopyFromErrorCallback(void *arg)
char *attval; char *attval;
attval = CopyLimitPrintoutLength(cstate->cur_attval); attval = CopyLimitPrintoutLength(cstate->cur_attval);
errcontext("COPY %s, line %llu, column %s: \"%s\"", errcontext("COPY %s, line %" PRIu64 ", column %s: \"%s\"",
cstate->cur_relname, cstate->cur_relname,
(unsigned long long) cstate->cur_lineno, cstate->cur_lineno,
cstate->cur_attname, cstate->cur_attname,
attval); attval);
pfree(attval); pfree(attval);
@ -292,9 +292,9 @@ CopyFromErrorCallback(void *arg)
else if (cstate->cur_attname) else if (cstate->cur_attname)
{ {
/* error is relevant to a particular column, value is NULL */ /* error is relevant to a particular column, value is NULL */
errcontext("COPY %s, line %llu, column %s: null input", errcontext("COPY %s, line %" PRIu64 ", column %s: null input",
cstate->cur_relname, cstate->cur_relname,
(unsigned long long) cstate->cur_lineno, cstate->cur_lineno,
cstate->cur_attname); cstate->cur_attname);
} }
else else
@ -309,16 +309,16 @@ CopyFromErrorCallback(void *arg)
char *lineval; char *lineval;
lineval = CopyLimitPrintoutLength(cstate->line_buf.data); lineval = CopyLimitPrintoutLength(cstate->line_buf.data);
errcontext("COPY %s, line %llu: \"%s\"", errcontext("COPY %s, line %" PRIu64 ": \"%s\"",
cstate->cur_relname, cstate->cur_relname,
(unsigned long long) cstate->cur_lineno, lineval); cstate->cur_lineno, lineval);
pfree(lineval); pfree(lineval);
} }
else else
{ {
errcontext("COPY %s, line %llu", errcontext("COPY %s, line %" PRIu64,
cstate->cur_relname, cstate->cur_relname,
(unsigned long long) cstate->cur_lineno); cstate->cur_lineno);
} }
} }
} }
@ -1168,8 +1168,8 @@ CopyFrom(CopyFromState cstate)
cstate->num_errors > cstate->opts.reject_limit) cstate->num_errors > cstate->opts.reject_limit)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("skipped more than REJECT_LIMIT (%lld) rows due to data type incompatibility", errmsg("skipped more than REJECT_LIMIT (%" PRId64 ") rows due to data type incompatibility",
(long long) cstate->opts.reject_limit))); cstate->opts.reject_limit)));
/* Repeat NextCopyFrom() until no soft error occurs */ /* Repeat NextCopyFrom() until no soft error occurs */
continue; continue;
@ -1471,10 +1471,10 @@ CopyFrom(CopyFromState cstate)
cstate->num_errors > 0 && cstate->num_errors > 0 &&
cstate->opts.log_verbosity >= COPY_LOG_VERBOSITY_DEFAULT) cstate->opts.log_verbosity >= COPY_LOG_VERBOSITY_DEFAULT)
ereport(NOTICE, ereport(NOTICE,
errmsg_plural("%llu row was skipped due to data type incompatibility", errmsg_plural("%" PRIu64 " row was skipped due to data type incompatibility",
"%llu rows were skipped due to data type incompatibility", "%" PRIu64 " rows were skipped due to data type incompatibility",
(unsigned long long) cstate->num_errors, cstate->num_errors,
(unsigned long long) cstate->num_errors)); cstate->num_errors));
if (bistate != NULL) if (bistate != NULL)
FreeBulkInsertState(bistate); FreeBulkInsertState(bistate);

8
src/backend/commands/copyfromparse.c
View File

@ -1053,16 +1053,16 @@ CopyFromTextLikeOneRow(CopyFromState cstate, ExprContext *econtext,
attval = CopyLimitPrintoutLength(cstate->cur_attval); attval = CopyLimitPrintoutLength(cstate->cur_attval);
ereport(NOTICE, ereport(NOTICE,
errmsg("skipping row due to data type incompatibility at line %llu for column \"%s\": \"%s\"", errmsg("skipping row due to data type incompatibility at line %" PRIu64 " for column \"%s\": \"%s\"",
(unsigned long long) cstate->cur_lineno, cstate->cur_lineno,
cstate->cur_attname, cstate->cur_attname,
attval)); attval));
pfree(attval); pfree(attval);
} }
else else
ereport(NOTICE, ereport(NOTICE,
errmsg("skipping row due to data type incompatibility at line %llu for column \"%s\": null input", errmsg("skipping row due to data type incompatibility at line %" PRIu64 " for column \"%s\": null input",
(unsigned long long) cstate->cur_lineno, cstate->cur_lineno,
cstate->cur_attname)); cstate->cur_attname));
/* reset relname_only */ /* reset relname_only */

54
src/backend/commands/explain.c
View File

@ -4126,17 +4126,17 @@ show_buffer_usage(ExplainState *es, const BufferUsage *usage)
{ {
appendStringInfoString(es->str, " shared"); appendStringInfoString(es->str, " shared");
if (usage->shared_blks_hit > 0) if (usage->shared_blks_hit > 0)
appendStringInfo(es->str, " hit=%lld", appendStringInfo(es->str, " hit=%" PRId64,
(long long) usage->shared_blks_hit); usage->shared_blks_hit);
if (usage->shared_blks_read > 0) if (usage->shared_blks_read > 0)
appendStringInfo(es->str, " read=%lld", appendStringInfo(es->str, " read=%" PRId64,
(long long) usage->shared_blks_read); usage->shared_blks_read);
if (usage->shared_blks_dirtied > 0) if (usage->shared_blks_dirtied > 0)
appendStringInfo(es->str, " dirtied=%lld", appendStringInfo(es->str, " dirtied=%" PRId64,
(long long) usage->shared_blks_dirtied); usage->shared_blks_dirtied);
if (usage->shared_blks_written > 0) if (usage->shared_blks_written > 0)
appendStringInfo(es->str, " written=%lld", appendStringInfo(es->str, " written=%" PRId64,
(long long) usage->shared_blks_written); usage->shared_blks_written);
if (has_local || has_temp) if (has_local || has_temp)
appendStringInfoChar(es->str, ','); appendStringInfoChar(es->str, ',');
} }
@ -4144,17 +4144,17 @@ show_buffer_usage(ExplainState *es, const BufferUsage *usage)
{ {
appendStringInfoString(es->str, " local"); appendStringInfoString(es->str, " local");
if (usage->local_blks_hit > 0) if (usage->local_blks_hit > 0)
appendStringInfo(es->str, " hit=%lld", appendStringInfo(es->str, " hit=%" PRId64,
(long long) usage->local_blks_hit); usage->local_blks_hit);
if (usage->local_blks_read > 0) if (usage->local_blks_read > 0)
appendStringInfo(es->str, " read=%lld", appendStringInfo(es->str, " read=%" PRId64,
(long long) usage->local_blks_read); usage->local_blks_read);
if (usage->local_blks_dirtied > 0) if (usage->local_blks_dirtied > 0)
appendStringInfo(es->str, " dirtied=%lld", appendStringInfo(es->str, " dirtied=%" PRId64,
(long long) usage->local_blks_dirtied); usage->local_blks_dirtied);
if (usage->local_blks_written > 0) if (usage->local_blks_written > 0)
appendStringInfo(es->str, " written=%lld", appendStringInfo(es->str, " written=%" PRId64,
(long long) usage->local_blks_written); usage->local_blks_written);
if (has_temp) if (has_temp)
appendStringInfoChar(es->str, ','); appendStringInfoChar(es->str, ',');
} }
@ -4162,11 +4162,11 @@ show_buffer_usage(ExplainState *es, const BufferUsage *usage)
{ {
appendStringInfoString(es->str, " temp"); appendStringInfoString(es->str, " temp");
if (usage->temp_blks_read > 0) if (usage->temp_blks_read > 0)
appendStringInfo(es->str, " read=%lld", appendStringInfo(es->str, " read=%" PRId64,
(long long) usage->temp_blks_read); usage->temp_blks_read);
if (usage->temp_blks_written > 0) if (usage->temp_blks_written > 0)
appendStringInfo(es->str, " written=%lld", appendStringInfo(es->str, " written=%" PRId64,
(long long) usage->temp_blks_written); usage->temp_blks_written);
} }
appendStringInfoChar(es->str, '\n'); appendStringInfoChar(es->str, '\n');
} }
@ -4276,17 +4276,17 @@ show_wal_usage(ExplainState *es, const WalUsage *usage)
appendStringInfoString(es->str, "WAL:"); appendStringInfoString(es->str, "WAL:");
if (usage->wal_records > 0) if (usage->wal_records > 0)
appendStringInfo(es->str, " records=%lld", appendStringInfo(es->str, " records=%" PRId64,
(long long) usage->wal_records); usage->wal_records);
if (usage->wal_fpi > 0) if (usage->wal_fpi > 0)
appendStringInfo(es->str, " fpi=%lld", appendStringInfo(es->str, " fpi=%" PRId64,
(long long) usage->wal_fpi); usage->wal_fpi);
if (usage->wal_bytes > 0) if (usage->wal_bytes > 0)
appendStringInfo(es->str, " bytes=" UINT64_FORMAT, appendStringInfo(es->str, " bytes=%" PRIu64,
usage->wal_bytes); usage->wal_bytes);
if (usage->wal_buffers_full > 0) if (usage->wal_buffers_full > 0)
appendStringInfo(es->str, " buffers full=%lld", appendStringInfo(es->str, " buffers full=%" PRId64,
(long long) usage->wal_buffers_full); usage->wal_buffers_full);
appendStringInfoChar(es->str, '\n'); appendStringInfoChar(es->str, '\n');
} }
} }

56
src/backend/commands/sequence.c
View File

@ -745,9 +745,9 @@ nextval_internal(Oid relid, bool check_permissions)
if (!cycle) if (!cycle)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED), (errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED),
errmsg("nextval: reached maximum value of sequence \"%s\" (%lld)", errmsg("nextval: reached maximum value of sequence \"%s\" (%" PRId64 ")",
RelationGetRelationName(seqrel), RelationGetRelationName(seqrel),
(long long) maxv))); maxv)));
next = minv; next = minv;
} }
else else
@ -764,9 +764,9 @@ nextval_internal(Oid relid, bool check_permissions)
if (!cycle) if (!cycle)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED), (errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED),
errmsg("nextval: reached minimum value of sequence \"%s\" (%lld)", errmsg("nextval: reached minimum value of sequence \"%s\" (%" PRId64 ")",
RelationGetRelationName(seqrel), RelationGetRelationName(seqrel),
(long long) minv))); minv)));
next = maxv; next = maxv;
} }
else else
@ -988,9 +988,9 @@ do_setval(Oid relid, int64 next, bool iscalled)
if ((next < minv) || (next > maxv)) if ((next < minv) || (next > maxv))
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
errmsg("setval: value %lld is out of bounds for sequence \"%s\" (%lld..%lld)", errmsg("setval: value %" PRId64 " is out of bounds for sequence \"%s\" (%" PRId64 "..%" PRId64 ")",
(long long) next, RelationGetRelationName(seqrel), next, RelationGetRelationName(seqrel),
(long long) minv, (long long) maxv))); minv, maxv)));
/* Set the currval() state only if iscalled = true */ /* Set the currval() state only if iscalled = true */
if (iscalled) if (iscalled)
@ -1463,8 +1463,8 @@ init_params(ParseState *pstate, List *options, bool for_identity,
|| (seqform->seqtypid == INT4OID && (seqform->seqmax < PG_INT32_MIN || seqform->seqmax > PG_INT32_MAX))) || (seqform->seqtypid == INT4OID && (seqform->seqmax < PG_INT32_MIN || seqform->seqmax > PG_INT32_MAX)))
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("MAXVALUE (%lld) is out of range for sequence data type %s", errmsg("MAXVALUE (%" PRId64 ") is out of range for sequence data type %s",
(long long) seqform->seqmax, seqform->seqmax,
format_type_be(seqform->seqtypid)))); format_type_be(seqform->seqtypid))));
/* MINVALUE (null arg means NO MINVALUE) */ /* MINVALUE (null arg means NO MINVALUE) */
@ -1495,17 +1495,17 @@ init_params(ParseState *pstate, List *options, bool for_identity,
|| (seqform->seqtypid == INT4OID && (seqform->seqmin < PG_INT32_MIN || seqform->seqmin > PG_INT32_MAX))) || (seqform->seqtypid == INT4OID && (seqform->seqmin < PG_INT32_MIN || seqform->seqmin > PG_INT32_MAX)))
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("MINVALUE (%lld) is out of range for sequence data type %s", errmsg("MINVALUE (%" PRId64 ") is out of range for sequence data type %s",
(long long) seqform->seqmin, seqform->seqmin,
format_type_be(seqform->seqtypid)))); format_type_be(seqform->seqtypid))));
/* crosscheck min/max */ /* crosscheck min/max */
if (seqform->seqmin >= seqform->seqmax) if (seqform->seqmin >= seqform->seqmax)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("MINVALUE (%lld) must be less than MAXVALUE (%lld)", errmsg("MINVALUE (%" PRId64 ") must be less than MAXVALUE (%" PRId64 ")",
(long long) seqform->seqmin, seqform->seqmin,
(long long) seqform->seqmax))); seqform->seqmax)));
/* START WITH */ /* START WITH */
if (start_value != NULL) if (start_value != NULL)
@ -1524,15 +1524,15 @@ init_params(ParseState *pstate, List *options, bool for_identity,
if (seqform->seqstart < seqform->seqmin) if (seqform->seqstart < seqform->seqmin)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("START value (%lld) cannot be less than MINVALUE (%lld)", errmsg("START value (%" PRId64 ") cannot be less than MINVALUE (%" PRId64 ")",
(long long) seqform->seqstart, seqform->seqstart,
(long long) seqform->seqmin))); seqform->seqmin)));
if (seqform->seqstart > seqform->seqmax) if (seqform->seqstart > seqform->seqmax)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("START value (%lld) cannot be greater than MAXVALUE (%lld)", errmsg("START value (%" PRId64 ") cannot be greater than MAXVALUE (%" PRId64 ")",
(long long) seqform->seqstart, seqform->seqstart,
(long long) seqform->seqmax))); seqform->seqmax)));
/* RESTART [WITH] */ /* RESTART [WITH] */
if (restart_value != NULL) if (restart_value != NULL)
@ -1554,15 +1554,15 @@ init_params(ParseState *pstate, List *options, bool for_identity,
if (seqdataform->last_value < seqform->seqmin) if (seqdataform->last_value < seqform->seqmin)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("RESTART value (%lld) cannot be less than MINVALUE (%lld)", errmsg("RESTART value (%" PRId64 ") cannot be less than MINVALUE (%" PRId64 ")",
(long long) seqdataform->last_value, seqdataform->last_value,
(long long) seqform->seqmin))); seqform->seqmin)));
if (seqdataform->last_value > seqform->seqmax) if (seqdataform->last_value > seqform->seqmax)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("RESTART value (%lld) cannot be greater than MAXVALUE (%lld)", errmsg("RESTART value (%" PRId64 ") cannot be greater than MAXVALUE (%" PRId64 ")",
(long long) seqdataform->last_value, seqdataform->last_value,
(long long) seqform->seqmax))); seqform->seqmax)));
/* CACHE */ /* CACHE */
if (cache_value != NULL) if (cache_value != NULL)
@ -1571,8 +1571,8 @@ init_params(ParseState *pstate, List *options, bool for_identity,
if (seqform->seqcache <= 0) if (seqform->seqcache <= 0)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("CACHE (%lld) must be greater than zero", errmsg("CACHE (%" PRId64 ") must be greater than zero",
(long long) seqform->seqcache))); seqform->seqcache)));
seqdataform->log_cnt = 0; seqdataform->log_cnt = 0;
} }
else if (isInit) else if (isInit)

4
src/backend/commands/vacuum.c
View File

@ -2614,9 +2614,9 @@ vac_bulkdel_one_index(IndexVacuumInfo *ivinfo, IndexBulkDeleteResult *istat,
dead_items); dead_items);
ereport(ivinfo->message_level, ereport(ivinfo->message_level,
(errmsg("scanned index \"%s\" to remove %lld row versions", (errmsg("scanned index \"%s\" to remove %" PRId64 " row versions",
RelationGetRelationName(ivinfo->index), RelationGetRelationName(ivinfo->index),
(long long) dead_items_info->num_items))); dead_items_info->num_items)));
return istat; return istat;
} }

18
src/backend/replication/logical/logical.c
View File

@ -1921,16 +1921,16 @@ UpdateDecodingStats(LogicalDecodingContext *ctx)
if (rb->spillBytes <= 0 && rb->streamBytes <= 0 && rb->totalBytes <= 0) if (rb->spillBytes <= 0 && rb->streamBytes <= 0 && rb->totalBytes <= 0)
return; return;
elog(DEBUG2, "UpdateDecodingStats: updating stats %p %lld %lld %lld %lld %lld %lld %lld %lld", elog(DEBUG2, "UpdateDecodingStats: updating stats %p %" PRId64 " %" PRId64 " %" PRId64 " %" PRId64 " %" PRId64 " %" PRId64 " %" PRId64 " %" PRId64,
rb, rb,
(long long) rb->spillTxns, rb->spillTxns,
(long long) rb->spillCount, rb->spillCount,
(long long) rb->spillBytes, rb->spillBytes,
(long long) rb->streamTxns, rb->streamTxns,
(long long) rb->streamCount, rb->streamCount,
(long long) rb->streamBytes, rb->streamBytes,
(long long) rb->totalTxns, rb->totalTxns,
(long long) rb->totalBytes); rb->totalBytes);
repSlotStat.spill_txns = rb->spillTxns; repSlotStat.spill_txns = rb->spillTxns;
repSlotStat.spill_count = rb->spillCount; repSlotStat.spill_count = rb->spillCount;

6
src/backend/replication/slot.c
View File

@ -1544,11 +1544,11 @@ ReportSlotInvalidation(ReplicationSlotInvalidationCause cause,
{ {
case RS_INVAL_WAL_REMOVED: case RS_INVAL_WAL_REMOVED:
{ {
unsigned long long ex = oldestLSN - restart_lsn; uint64 ex = oldestLSN - restart_lsn;
appendStringInfo(&err_detail, appendStringInfo(&err_detail,
ngettext("The slot's restart_lsn %X/%X exceeds the limit by %llu byte.", ngettext("The slot's restart_lsn %X/%X exceeds the limit by %" PRIu64 " byte.",
"The slot's restart_lsn %X/%X exceeds the limit by %llu bytes.", "The slot's restart_lsn %X/%X exceeds the limit by %" PRIu64 " bytes.",
ex), ex),
LSN_FORMAT_ARGS(restart_lsn), LSN_FORMAT_ARGS(restart_lsn),
ex); ex);

4
src/backend/storage/ipc/ipc.c
View File

@ -399,8 +399,8 @@ cancel_before_shmem_exit(pg_on_exit_callback function, Datum arg)
before_shmem_exit_list[before_shmem_exit_index - 1].arg == arg) before_shmem_exit_list[before_shmem_exit_index - 1].arg == arg)
--before_shmem_exit_index; --before_shmem_exit_index;
else else
elog(ERROR, "before_shmem_exit callback (%p,0x%llx) is not the latest entry", elog(ERROR, "before_shmem_exit callback (%p,0x%" PRIxPTR ") is not the latest entry",
function, (long long) arg); function, arg);
} }
/* ---------------------------------------------------------------- /* ----------------------------------------------------------------

6
src/backend/storage/ipc/signalfuncs.c
View File

@ -215,10 +215,10 @@ pg_wait_until_termination(int pid, int64 timeout)
} while (remainingtime > 0); } while (remainingtime > 0);
ereport(WARNING, ereport(WARNING,
(errmsg_plural("backend with PID %d did not terminate within %lld millisecond", (errmsg_plural("backend with PID %d did not terminate within %" PRId64 " millisecond",
"backend with PID %d did not terminate within %lld milliseconds", "backend with PID %d did not terminate within %" PRId64 " milliseconds",
timeout, timeout,
pid, (long long int) timeout))); pid, timeout)));
return false; return false;
} }

16
src/backend/utils/activity/pgstat.c
View File

@ -1679,9 +1679,9 @@ pgstat_write_statsfile(void)
*/ */
if (!pgstat_is_kind_valid(ps->key.kind)) if (!pgstat_is_kind_valid(ps->key.kind))
{ {
elog(WARNING, "found unknown stats entry %u/%u/%llu", elog(WARNING, "found unknown stats entry %u/%u/%" PRIu64,
ps->key.kind, ps->key.dboid, ps->key.kind, ps->key.dboid,
(unsigned long long) ps->key.objid); ps->key.objid);
continue; continue;
} }
@ -1903,9 +1903,9 @@ pgstat_read_statsfile(void)
if (!pgstat_is_kind_valid(key.kind)) if (!pgstat_is_kind_valid(key.kind))
{ {
elog(WARNING, "invalid stats kind for entry %u/%u/%llu of type %c", elog(WARNING, "invalid stats kind for entry %u/%u/%" PRIu64 " of type %c",
key.kind, key.dboid, key.kind, key.dboid,
(unsigned long long) key.objid, t); key.objid, t);
goto error; goto error;
} }
} }
@ -1976,9 +1976,9 @@ pgstat_read_statsfile(void)
if (found) if (found)
{ {
dshash_release_lock(pgStatLocal.shared_hash, p); dshash_release_lock(pgStatLocal.shared_hash, p);
elog(WARNING, "found duplicate stats entry %u/%u/%llu of type %c", elog(WARNING, "found duplicate stats entry %u/%u/%" PRIu64 " of type %c",
key.kind, key.dboid, key.kind, key.dboid,
(unsigned long long) key.objid, t); key.objid, t);
goto error; goto error;
} }
@ -1989,9 +1989,9 @@ pgstat_read_statsfile(void)
pgstat_get_entry_data(key.kind, header), pgstat_get_entry_data(key.kind, header),
pgstat_get_entry_len(key.kind))) pgstat_get_entry_len(key.kind)))
{ {
elog(WARNING, "could not read data for entry %u/%u/%llu of type %c", elog(WARNING, "could not read data for entry %u/%u/%" PRIu64 " of type %c",
key.kind, key.dboid, key.kind, key.dboid,
(unsigned long long) key.objid, t); key.objid, t);
goto error; goto error;
} }

4
src/backend/utils/activity/pgstat_replslot.c
View File

@ -194,8 +194,8 @@ pgstat_replslot_to_serialized_name_cb(const PgStat_HashKey *key, const PgStatSha
* at the offset. * at the offset.
*/ */
if (!ReplicationSlotName(key->objid, name)) if (!ReplicationSlotName(key->objid, name))
elog(ERROR, "could not find name for replication slot index %llu", elog(ERROR, "could not find name for replication slot index %" PRIu64,
(unsigned long long) key->objid); key->objid);
} }
bool bool

4
src/backend/utils/activity/pgstat_shmem.c
View File

@ -864,10 +864,10 @@ pgstat_drop_entry_internal(PgStatShared_HashEntry *shent,
*/ */
if (shent->dropped) if (shent->dropped)
elog(ERROR, elog(ERROR,
"trying to drop stats entry already dropped: kind=%s dboid=%u objid=%llu refcount=%u", "trying to drop stats entry already dropped: kind=%s dboid=%u objid=%" PRIu64 " refcount=%u",
pgstat_get_kind_info(shent->key.kind)->name, pgstat_get_kind_info(shent->key.kind)->name,
shent->key.dboid, shent->key.dboid,
(unsigned long long) shent->key.objid, shent->key.objid,
pg_atomic_read_u32(&shent->refcount)); pg_atomic_read_u32(&shent->refcount));
shent->dropped = true; shent->dropped = true;

4
src/backend/utils/activity/pgstat_xact.c
View File

@ -363,9 +363,9 @@ pgstat_create_transactional(PgStat_Kind kind, Oid dboid, uint64 objid)
if (pgstat_get_entry_ref(kind, dboid, objid, false, NULL)) if (pgstat_get_entry_ref(kind, dboid, objid, false, NULL))
{ {
ereport(WARNING, ereport(WARNING,
errmsg("resetting existing statistics for kind %s, db=%u, oid=%llu", errmsg("resetting existing statistics for kind %s, db=%u, oid=%" PRIu64,
(pgstat_get_kind_info(kind))->name, dboid, (pgstat_get_kind_info(kind))->name, dboid,
(unsigned long long) objid)); objid));
pgstat_reset(kind, dboid, objid); pgstat_reset(kind, dboid, objid);
} }

24
src/backend/utils/adt/datetime.c
View File

@ -4630,7 +4630,7 @@ AddISO8601IntPart(char *cp, int64 value, char units)
{ {
if (value == 0) if (value == 0)
return cp; return cp;
sprintf(cp, "%lld%c", (long long) value, units); sprintf(cp, "%" PRId64 "%c", value, units);
return cp + strlen(cp); return cp + strlen(cp);
} }
@ -4641,10 +4641,10 @@ AddPostgresIntPart(char *cp, int64 value, const char *units,
{ {
if (value == 0) if (value == 0)
return cp; return cp;
sprintf(cp, "%s%s%lld %s%s", sprintf(cp, "%s%s%" PRId64 " %s%s",
(!*is_zero) ? " " : "", (!*is_zero) ? " " : "",
(*is_before && value > 0) ? "+" : "", (*is_before && value > 0) ? "+" : "",
(long long) value, value,
units, units,
(value != 1) ? "s" : ""); (value != 1) ? "s" : "");
@ -4672,7 +4672,7 @@ AddVerboseIntPart(char *cp, int64 value, const char *units,
} }
else if (*is_before) else if (*is_before)
value = -value; value = -value;
sprintf(cp, " %lld %s%s", (long long) value, units, (value == 1) ? "" : "s"); sprintf(cp, " %" PRId64 " %s%s", value, units, (value == 1) ? "" : "s");
*is_zero = false; *is_zero = false;
return cp + strlen(cp); return cp + strlen(cp);
} }
@ -4767,10 +4767,10 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 || char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+'; sec < 0 || fsec < 0) ? '-' : '+';
sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:", sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon), year_sign, abs(year), abs(mon),
day_sign, (long long) i64abs(mday), day_sign, i64abs(mday),
sec_sign, (long long) i64abs(hour), abs(min)); sec_sign, i64abs(hour), abs(min));
cp += strlen(cp); cp += strlen(cp);
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true); cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0'; *cp = '\0';
@ -4781,15 +4781,15 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
} }
else if (has_day) else if (has_day)
{ {
sprintf(cp, "%lld %lld:%02d:", sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
(long long) mday, (long long) hour, min); mday, hour, min);
cp += strlen(cp); cp += strlen(cp);
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true); cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0'; *cp = '\0';
} }
else else
{ {
sprintf(cp, "%lld:%02d:", (long long) hour, min); sprintf(cp, "%" PRId64 ":%02d:", hour, min);
cp += strlen(cp); cp += strlen(cp);
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true); cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0'; *cp = '\0';
@ -4839,10 +4839,10 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
{ {
bool minus = (hour < 0 || min < 0 || sec < 0 || fsec < 0); bool minus = (hour < 0 || min < 0 || sec < 0 || fsec < 0);
sprintf(cp, "%s%s%02lld:%02d:", sprintf(cp, "%s%s%02" PRId64 ":%02d:",
is_zero ? "" : " ", is_zero ? "" : " ",
(minus ? "-" : (is_before ? "+" : "")), (minus ? "-" : (is_before ? "+" : "")),
(long long) i64abs(hour), abs(min)); i64abs(hour), abs(min));
cp += strlen(cp); cp += strlen(cp);
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true); cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0'; *cp = '\0';

8
src/backend/utils/adt/varlena.c
View File

@ -3296,8 +3296,8 @@ byteaGetBit(PG_FUNCTION_ARGS)
if (n < 0 || n >= (int64) len * 8) if (n < 0 || n >= (int64) len * 8)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR), (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("index %lld out of valid range, 0..%lld", errmsg("index %" PRId64 " out of valid range, 0..%" PRId64,
(long long) n, (long long) len * 8 - 1))); n, (int64) len * 8 - 1)));
/* n/8 is now known < len, so safe to cast to int */ /* n/8 is now known < len, so safe to cast to int */
byteNo = (int) (n / 8); byteNo = (int) (n / 8);
@ -3368,8 +3368,8 @@ byteaSetBit(PG_FUNCTION_ARGS)
if (n < 0 || n >= (int64) len * 8) if (n < 0 || n >= (int64) len * 8)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR), (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("index %lld out of valid range, 0..%lld", errmsg("index %" PRId64 " out of valid range, 0..%" PRId64,
(long long) n, (long long) len * 8 - 1))); n, (int64) len * 8 - 1)));
/* n/8 is now known < len, so safe to cast to int */ /* n/8 is now known < len, so safe to cast to int */
byteNo = (int) (n / 8); byteNo = (int) (n / 8);

4
src/backend/utils/adt/xid8funcs.c
View File

@ -117,8 +117,8 @@ TransactionIdInRecentPast(FullTransactionId fxid, TransactionId *extracted_xid)
if (!FullTransactionIdPrecedes(fxid, now_fullxid)) if (!FullTransactionIdPrecedes(fxid, now_fullxid))
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("transaction ID %llu is in the future", errmsg("transaction ID %" PRIu64 " is in the future",
(unsigned long long) U64FromFullTransactionId(fxid)))); U64FromFullTransactionId(fxid))));
/* /*
* TransamVariables->oldestClogXid is protected by XactTruncationLock, but * TransamVariables->oldestClogXid is protected by XactTruncationLock, but

2
src/backend/utils/error/csvlog.c
View File

@ -248,7 +248,7 @@ write_csvlog(ErrorData *edata)
appendStringInfoChar(&buf, ','); appendStringInfoChar(&buf, ',');
/* query id */ /* query id */
appendStringInfo(&buf, "%lld", (long long) pgstat_get_my_query_id()); appendStringInfo(&buf, "%" PRId64, pgstat_get_my_query_id());
appendStringInfoChar(&buf, '\n'); appendStringInfoChar(&buf, '\n');

8
src/backend/utils/error/elog.c
View File

@ -3152,11 +3152,11 @@ log_status_format(StringInfo buf, const char *format, ErrorData *edata)
break; break;
case 'Q': case 'Q':
if (padding != 0) if (padding != 0)
appendStringInfo(buf, "%*lld", padding, appendStringInfo(buf, "%*" PRId64, padding,
(long long) pgstat_get_my_query_id()); pgstat_get_my_query_id());
else else
appendStringInfo(buf, "%lld", appendStringInfo(buf, "%" PRId64,
(long long) pgstat_get_my_query_id()); pgstat_get_my_query_id());
break; break;
default: default:
/* format error - ignore it */ /* format error - ignore it */

4
src/backend/utils/error/jsonlog.c
View File

@ -284,8 +284,8 @@ write_jsonlog(ErrorData *edata)
} }
/* query id */ /* query id */
appendJSONKeyValueFmt(&buf, "query_id", false, "%lld", appendJSONKeyValueFmt(&buf, "query_id", false, "%" PRId64,
(long long) pgstat_get_my_query_id()); pgstat_get_my_query_id());
/* Finish string */ /* Finish string */
appendStringInfoChar(&buf, '}'); appendStringInfoChar(&buf, '}');

16
src/backend/utils/mmgr/mcxt.c
View File

@ -285,31 +285,31 @@ MemoryContextTraverseNext(MemoryContext curr, MemoryContext top)
static void static void
BogusFree(void *pointer) BogusFree(void *pointer)
{ {
elog(ERROR, "pfree called with invalid pointer %p (header 0x%016llx)", elog(ERROR, "pfree called with invalid pointer %p (header 0x%016" PRIx64 ")",
pointer, (unsigned long long) GetMemoryChunkHeader(pointer)); pointer, GetMemoryChunkHeader(pointer));
} }
static void * static void *
BogusRealloc(void *pointer, Size size, int flags) BogusRealloc(void *pointer, Size size, int flags)
{ {
elog(ERROR, "repalloc called with invalid pointer %p (header 0x%016llx)", elog(ERROR, "repalloc called with invalid pointer %p (header 0x%016" PRIx64 ")",
pointer, (unsigned long long) GetMemoryChunkHeader(pointer)); pointer, GetMemoryChunkHeader(pointer));
return NULL; /* keep compiler quiet */ return NULL; /* keep compiler quiet */
} }
static MemoryContext static MemoryContext
BogusGetChunkContext(void *pointer) BogusGetChunkContext(void *pointer)
{ {
elog(ERROR, "GetMemoryChunkContext called with invalid pointer %p (header 0x%016llx)", elog(ERROR, "GetMemoryChunkContext called with invalid pointer %p (header 0x%016" PRIx64 ")",
pointer, (unsigned long long) GetMemoryChunkHeader(pointer)); pointer, GetMemoryChunkHeader(pointer));
return NULL; /* keep compiler quiet */ return NULL; /* keep compiler quiet */
} }
static Size static Size
BogusGetChunkSpace(void *pointer) BogusGetChunkSpace(void *pointer)
{ {
elog(ERROR, "GetMemoryChunkSpace called with invalid pointer %p (header 0x%016llx)", elog(ERROR, "GetMemoryChunkSpace called with invalid pointer %p (header 0x%016" PRIx64 ")",
pointer, (unsigned long long) GetMemoryChunkHeader(pointer)); pointer, GetMemoryChunkHeader(pointer));
return 0; /* keep compiler quiet */ return 0; /* keep compiler quiet */
} }

16
src/backend/utils/sort/logtape.c
View File

@ -263,8 +263,8 @@ ltsWriteBlock(LogicalTapeSet *lts, int64 blocknum, const void *buffer)
if (BufFileSeekBlock(lts->pfile, blocknum) != 0) if (BufFileSeekBlock(lts->pfile, blocknum) != 0)
ereport(ERROR, ereport(ERROR,
(errcode_for_file_access(), (errcode_for_file_access(),
errmsg("could not seek to block %lld of temporary file", errmsg("could not seek to block %" PRId64 " of temporary file",
(long long) blocknum))); blocknum)));
BufFileWrite(lts->pfile, buffer, BLCKSZ); BufFileWrite(lts->pfile, buffer, BLCKSZ);
/* Update nBlocksWritten, if we extended the file */ /* Update nBlocksWritten, if we extended the file */
@ -284,8 +284,8 @@ ltsReadBlock(LogicalTapeSet *lts, int64 blocknum, void *buffer)
if (BufFileSeekBlock(lts->pfile, blocknum) != 0) if (BufFileSeekBlock(lts->pfile, blocknum) != 0)
ereport(ERROR, ereport(ERROR,
(errcode_for_file_access(), (errcode_for_file_access(),
errmsg("could not seek to block %lld of temporary file", errmsg("could not seek to block %" PRId64 " of temporary file",
(long long) blocknum))); blocknum)));
BufFileReadExact(lts->pfile, buffer, BLCKSZ); BufFileReadExact(lts->pfile, buffer, BLCKSZ);
} }
@ -1100,10 +1100,10 @@ LogicalTapeBackspace(LogicalTape *lt, size_t size)
ltsReadBlock(lt->tapeSet, prev, lt->buffer); ltsReadBlock(lt->tapeSet, prev, lt->buffer);
if (TapeBlockGetTrailer(lt->buffer)->next != lt->curBlockNumber) if (TapeBlockGetTrailer(lt->buffer)->next != lt->curBlockNumber)
elog(ERROR, "broken tape, next of block %lld is %lld, expected %lld", elog(ERROR, "broken tape, next of block %" PRId64 " is %" PRId64 ", expected %" PRId64,
(long long) prev, prev,
(long long) (TapeBlockGetTrailer(lt->buffer)->next), TapeBlockGetTrailer(lt->buffer)->next,
(long long) lt->curBlockNumber); lt->curBlockNumber);
lt->nbytes = TapeBlockPayloadSize; lt->nbytes = TapeBlockPayloadSize;
lt->curBlockNumber = prev; lt->curBlockNumber = prev;

8
src/backend/utils/sort/tuplesort.c
View File

@ -918,13 +918,13 @@ tuplesort_free(Tuplesortstate *state)
if (trace_sort) if (trace_sort)
{ {
if (state->tapeset) if (state->tapeset)
elog(LOG, "%s of worker %d ended, %lld disk blocks used: %s", elog(LOG, "%s of worker %d ended, %" PRId64 " disk blocks used: %s",
SERIAL(state) ? "external sort" : "parallel external sort", SERIAL(state) ? "external sort" : "parallel external sort",
state->worker, (long long) spaceUsed, pg_rusage_show(&state->ru_start)); state->worker, spaceUsed, pg_rusage_show(&state->ru_start));
else else
elog(LOG, "%s of worker %d ended, %lld KB used: %s", elog(LOG, "%s of worker %d ended, %" PRId64 " KB used: %s",
SERIAL(state) ? "internal sort" : "unperformed parallel sort", SERIAL(state) ? "internal sort" : "unperformed parallel sort",
state->worker, (long long) spaceUsed, pg_rusage_show(&state->ru_start)); state->worker, spaceUsed, pg_rusage_show(&state->ru_start));
} }
TRACE_POSTGRESQL_SORT_DONE(state->tapeset != NULL, spaceUsed); TRACE_POSTGRESQL_SORT_DONE(state->tapeset != NULL, spaceUsed);

10
src/bin/pg_basebackup/pg_createsubscriber.c
View File

@ -614,8 +614,7 @@ get_primary_sysid(const char *conninfo)
sysid = strtou64(PQgetvalue(res, 0, 0), NULL, 10); sysid = strtou64(PQgetvalue(res, 0, 0), NULL, 10);
pg_log_info("system identifier is %llu on publisher", pg_log_info("system identifier is %" PRIu64 " on publisher", sysid);
(unsigned long long) sysid);
PQclear(res); PQclear(res);
disconnect_database(conn, false); disconnect_database(conn, false);
@ -643,8 +642,7 @@ get_standby_sysid(const char *datadir)
sysid = cf->system_identifier; sysid = cf->system_identifier;
pg_log_info("system identifier is %llu on subscriber", pg_log_info("system identifier is %" PRIu64 " on subscriber", sysid);
(unsigned long long) sysid);
pg_free(cf); pg_free(cf);
@ -684,8 +682,8 @@ modify_subscriber_sysid(const struct CreateSubscriberOptions *opt)
if (!dry_run) if (!dry_run)
update_controlfile(subscriber_dir, cf, true); update_controlfile(subscriber_dir, cf, true);
pg_log_info("system identifier is %llu on subscriber", pg_log_info("system identifier is %" PRIu64 " on subscriber",
(unsigned long long) cf->system_identifier); cf->system_identifier);
pg_log_info("running pg_resetwal on the subscriber"); pg_log_info("running pg_resetwal on the subscriber");

15
src/bin/pg_combinebackup/pg_combinebackup.c
View File

@ -302,10 +302,10 @@ main(int argc, char *argv[])
controlpath = psprintf("%s/%s", prior_backup_dirs[i], "global/pg_control"); controlpath = psprintf("%s/%s", prior_backup_dirs[i], "global/pg_control");
pg_fatal("%s: manifest system identifier is %llu, but control file has %llu", pg_fatal("%s: manifest system identifier is %" PRIu64 ", but control file has %" PRIu64,
controlpath, controlpath,
(unsigned long long) manifests[i]->system_identifier, manifests[i]->system_identifier,
(unsigned long long) system_identifier); system_identifier);
} }
} }
@ -631,9 +631,9 @@ check_control_files(int n_backups, char **backup_dirs)
if (i == n_backups - 1) if (i == n_backups - 1)
system_identifier = control_file->system_identifier; system_identifier = control_file->system_identifier;
else if (system_identifier != control_file->system_identifier) else if (system_identifier != control_file->system_identifier)
pg_fatal("%s: expected system identifier %llu, but found %llu", pg_fatal("%s: expected system identifier %" PRIu64 ", but found %" PRIu64,
controlpath, (unsigned long long) system_identifier, controlpath, system_identifier,
(unsigned long long) control_file->system_identifier); control_file->system_identifier);
/* /*
* Detect checksum mismatches, but only if the last backup in the * Detect checksum mismatches, but only if the last backup in the
@ -654,8 +654,7 @@ check_control_files(int n_backups, char **backup_dirs)
* If debug output is enabled, make a note of the system identifier that * If debug output is enabled, make a note of the system identifier that
* we found in all of the relevant control files. * we found in all of the relevant control files.
*/ */
pg_log_debug("system identifier is %llu", pg_log_debug("system identifier is %" PRIu64, system_identifier);
(unsigned long long) system_identifier);
/* /*
* Warn the user if not all backups are in the same state with regards to * Warn the user if not all backups are in the same state with regards to

3
src/bin/pg_combinebackup/write_manifest.c
View File

@ -104,8 +104,7 @@ add_file_to_manifest(manifest_writer *mwriter, const char *manifest_path,
appendStringInfoString(&mwriter->buf, "\", "); appendStringInfoString(&mwriter->buf, "\", ");
} }
appendStringInfo(&mwriter->buf, "\"Size\": %llu, ", appendStringInfo(&mwriter->buf, "\"Size\": %" PRIu64 ", ", size);
(unsigned long long) size);
appendStringInfoString(&mwriter->buf, "\"Last-Modified\": \""); appendStringInfoString(&mwriter->buf, "\"Last-Modified\": \"");
enlargeStringInfo(&mwriter->buf, 128); enlargeStringInfo(&mwriter->buf, 128);

4
src/bin/pg_controldata/pg_controldata.c
View File

@ -239,8 +239,8 @@ main(int argc, char *argv[])
ControlFile->pg_control_version); ControlFile->pg_control_version);
printf(_("Catalog version number: %u\n"), printf(_("Catalog version number: %u\n"),
ControlFile->catalog_version_no); ControlFile->catalog_version_no);
printf(_("Database system identifier: %llu\n"), printf(_("Database system identifier: %" PRIu64 "\n"),
(unsigned long long) ControlFile->system_identifier); ControlFile->system_identifier);
printf(_("Database cluster state: %s\n"), printf(_("Database cluster state: %s\n"),
dbState(ControlFile->state)); dbState(ControlFile->state));
printf(_("pg_control last modified: %s\n"), printf(_("pg_control last modified: %s\n"),

4
src/bin/pg_resetwal/pg_resetwal.c
View File

@ -746,8 +746,8 @@ PrintControlValues(bool guessed)
ControlFile.pg_control_version); ControlFile.pg_control_version);
printf(_("Catalog version number: %u\n"), printf(_("Catalog version number: %u\n"),
ControlFile.catalog_version_no); ControlFile.catalog_version_no);
printf(_("Database system identifier: %llu\n"), printf(_("Database system identifier: %" PRIu64 "\n"),
(unsigned long long) ControlFile.system_identifier); ControlFile.system_identifier);
printf(_("Latest checkpoint's TimeLineID: %u\n"), printf(_("Latest checkpoint's TimeLineID: %u\n"),
ControlFile.checkPointCopy.ThisTimeLineID); ControlFile.checkPointCopy.ThisTimeLineID);
printf(_("Latest checkpoint's full_page_writes: %s\n"), printf(_("Latest checkpoint's full_page_writes: %s\n"),

8
src/bin/pg_rewind/libpq_source.c
View File

@ -567,8 +567,8 @@ process_queued_fetch_requests(libpq_source *src)
} }
else else
{ {
pg_log_debug("received chunk for file \"%s\", offset %lld, size %d", pg_log_debug("received chunk for file \"%s\", offset %" PRId64 ", size %d",
filename, (long long int) chunkoff, chunksize); filename, chunkoff, chunksize);
if (strcmp(filename, rq->path) != 0) if (strcmp(filename, rq->path) != 0)
{ {
@ -576,8 +576,8 @@ process_queued_fetch_requests(libpq_source *src)
filename, rq->path); filename, rq->path);
} }
if (chunkoff != rq->offset) if (chunkoff != rq->offset)
pg_fatal("received data at offset %lld of file \"%s\", when requested for offset %lld", pg_fatal("received data at offset %" PRId64 " of file \"%s\", when requested for offset %lld",
(long long int) chunkoff, rq->path, (long long int) rq->offset); chunkoff, rq->path, (long long int) rq->offset);
/* /*
* We should not receive more data than we requested, or * We should not receive more data than we requested, or

16
src/bin/pg_verifybackup/astreamer_verify.c
View File

@ -207,11 +207,11 @@ member_verify_header(astreamer *streamer, astreamer_member *member)
if (m->size != member->size) if (m->size != member->size)
{ {
report_backup_error(mystreamer->context, report_backup_error(mystreamer->context,
"\"%s\" has size %llu in \"%s\" but size %llu in the manifest", "\"%s\" has size %llu in \"%s\" but size %" PRIu64 " in the manifest",
member->pathname, member->pathname,
(unsigned long long) member->size, (unsigned long long) member->size,
mystreamer->archive_name, mystreamer->archive_name,
(unsigned long long) m->size); m->size);
m->bad = true; m->bad = true;
return; return;
} }
@ -296,10 +296,10 @@ member_verify_checksum(astreamer *streamer)
if (mystreamer->checksum_bytes != m->size) if (mystreamer->checksum_bytes != m->size)
{ {
report_backup_error(mystreamer->context, report_backup_error(mystreamer->context,
"file \"%s\" in \"%s\" should contain %llu bytes, but read %llu bytes", "file \"%s\" in \"%s\" should contain %" PRIu64 " bytes, but read %" PRIu64 " bytes",
m->pathname, mystreamer->archive_name, m->pathname, mystreamer->archive_name,
(unsigned long long) m->size, m->size,
(unsigned long long) mystreamer->checksum_bytes); mystreamer->checksum_bytes);
return; return;
} }
@ -408,11 +408,11 @@ member_verify_control_data(astreamer *streamer)
/* System identifiers should match. */ /* System identifiers should match. */
if (manifest->system_identifier != if (manifest->system_identifier !=
mystreamer->control_file.system_identifier) mystreamer->control_file.system_identifier)
report_fatal_error("%s: %s: manifest system identifier is %llu, but control file has %llu", report_fatal_error("%s: %s: manifest system identifier is %" PRIu64 ", but control file has %" PRIu64,
mystreamer->archive_name, mystreamer->archive_name,
mystreamer->mfile->pathname, mystreamer->mfile->pathname,
(unsigned long long) manifest->system_identifier, manifest->system_identifier,
(unsigned long long) mystreamer->control_file.system_identifier); mystreamer->control_file.system_identifier);
} }
/* /*

11
src/bin/pg_verifybackup/pg_verifybackup.c
View File

@ -770,10 +770,10 @@ verify_control_file(const char *controlpath, uint64 manifest_system_identifier)
/* System identifiers should match. */ /* System identifiers should match. */
if (manifest_system_identifier != control_file->system_identifier) if (manifest_system_identifier != control_file->system_identifier)
report_fatal_error("%s: manifest system identifier is %llu, but control file has %llu", report_fatal_error("%s: manifest system identifier is %" PRIu64 ", but control file has %" PRIu64,
controlpath, controlpath,
(unsigned long long) manifest_system_identifier, manifest_system_identifier,
(unsigned long long) control_file->system_identifier); control_file->system_identifier);
/* Release memory. */ /* Release memory. */
pfree(control_file); pfree(control_file);
@ -1165,9 +1165,8 @@ verify_file_checksum(verifier_context *context, manifest_file *m,
if (bytes_read != m->size) if (bytes_read != m->size)
{ {
report_backup_error(context, report_backup_error(context,
"file \"%s\" should contain %llu bytes, but read %llu bytes", "file \"%s\" should contain %" PRIu64 " bytes, but read %" PRIu64,
relpath, (unsigned long long) m->size, relpath, m->size, bytes_read);
(unsigned long long) bytes_read);
return; return;
} }

10
src/fe_utils/print.c
View File

@ -3185,9 +3185,9 @@ printTableInit(printTableContent *const content, const printTableOpt *opt,
/* Catch possible overflow. Using >= here allows adding 1 below */ /* Catch possible overflow. Using >= here allows adding 1 below */
if (total_cells >= SIZE_MAX / sizeof(*content->cells)) if (total_cells >= SIZE_MAX / sizeof(*content->cells))
{ {
fprintf(stderr, _("Cannot print table contents: number of cells %lld is equal to or exceeds maximum %lld.\n"), fprintf(stderr, _("Cannot print table contents: number of cells %" PRId64 " is equal to or exceeds maximum %zu.\n"),
(long long int) total_cells, total_cells,
(long long int) (SIZE_MAX / sizeof(*content->cells))); SIZE_MAX / sizeof(*content->cells));
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
content->cells = pg_malloc0((total_cells + 1) * sizeof(*content->cells)); content->cells = pg_malloc0((total_cells + 1) * sizeof(*content->cells));
@ -3269,8 +3269,8 @@ printTableAddCell(printTableContent *const content, char *cell,
total_cells = (uint64) content->ncolumns * content->nrows; total_cells = (uint64) content->ncolumns * content->nrows;
if (content->cellsadded >= total_cells) if (content->cellsadded >= total_cells)
{ {
fprintf(stderr, _("Cannot add cell to table content: total cell count of %lld exceeded.\n"), fprintf(stderr, _("Cannot add cell to table content: total cell count of %" PRId64 " exceeded.\n"),
(long long int) total_cells); total_cells);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }

6
src/include/lib/radixtree.h
View File

@ -2754,7 +2754,7 @@ RT_SCOPE void
RT_STATS(RT_RADIX_TREE * tree) RT_STATS(RT_RADIX_TREE * tree)
{ {
fprintf(stderr, "max_val = " UINT64_FORMAT "\n", tree->ctl->max_val); fprintf(stderr, "max_val = " UINT64_FORMAT "\n", tree->ctl->max_val);
fprintf(stderr, "num_keys = %lld\n", (long long) tree->ctl->num_keys); fprintf(stderr, "num_keys = %" PRId64 "\n", tree->ctl->num_keys);
#ifdef RT_SHMEM #ifdef RT_SHMEM
fprintf(stderr, "handle = " DSA_POINTER_FORMAT "\n", tree->ctl->handle); fprintf(stderr, "handle = " DSA_POINTER_FORMAT "\n", tree->ctl->handle);
@ -2766,10 +2766,10 @@ RT_STATS(RT_RADIX_TREE * tree)
{ {
RT_SIZE_CLASS_ELEM size_class = RT_SIZE_CLASS_INFO[i]; RT_SIZE_CLASS_ELEM size_class = RT_SIZE_CLASS_INFO[i];
fprintf(stderr, ", n%d = %lld", size_class.fanout, (long long) tree->ctl->num_nodes[i]); fprintf(stderr, ", n%d = %" PRId64, size_class.fanout, tree->ctl->num_nodes[i]);
} }
fprintf(stderr, ", leaves = %lld", (long long) tree->ctl->num_leaves); fprintf(stderr, ", leaves = %" PRId64, tree->ctl->num_leaves);
fprintf(stderr, "\n"); fprintf(stderr, "\n");
} }

4
src/test/modules/test_copy_callbacks/test_copy_callbacks.c
View File

@ -42,8 +42,8 @@ test_copy_to_callback(PG_FUNCTION_ARGS)
processed = DoCopyTo(cstate); processed = DoCopyTo(cstate);
EndCopyTo(cstate); EndCopyTo(cstate);
ereport(NOTICE, (errmsg("COPY TO callback has processed %lld rows", ereport(NOTICE, (errmsg("COPY TO callback has processed %" PRId64 " rows",
(long long) processed))); processed)));
table_close(rel, NoLock); table_close(rel, NoLock);

8
src/test/modules/test_slru/test_slru.c
View File

@ -151,8 +151,8 @@ test_slru_page_sync(PG_FUNCTION_ARGS)
ftag.segno = pageno / SLRU_PAGES_PER_SEGMENT; ftag.segno = pageno / SLRU_PAGES_PER_SEGMENT;
SlruSyncFileTag(TestSlruCtl, &ftag, path); SlruSyncFileTag(TestSlruCtl, &ftag, path);
elog(NOTICE, "Called SlruSyncFileTag() for segment %lld on path %s", elog(NOTICE, "Called SlruSyncFileTag() for segment %" PRId64 " on path %s",
(long long) ftag.segno, path); ftag.segno, path);
PG_RETURN_VOID(); PG_RETURN_VOID();
} }
@ -166,8 +166,8 @@ test_slru_page_delete(PG_FUNCTION_ARGS)
ftag.segno = pageno / SLRU_PAGES_PER_SEGMENT; ftag.segno = pageno / SLRU_PAGES_PER_SEGMENT;
SlruDeleteSegment(TestSlruCtl, ftag.segno); SlruDeleteSegment(TestSlruCtl, ftag.segno);
elog(NOTICE, "Called SlruDeleteSegment() for segment %lld", elog(NOTICE, "Called SlruDeleteSegment() for segment %" PRId64,
(long long) ftag.segno); ftag.segno);
PG_RETURN_VOID(); PG_RETURN_VOID();
} }

10
src/test/modules/xid_wraparound/xid_wraparound.c
View File

@ -35,7 +35,7 @@ consume_xids(PG_FUNCTION_ARGS)
FullTransactionId lastxid; FullTransactionId lastxid;
if (nxids < 0) if (nxids < 0)
elog(ERROR, "invalid nxids argument: %lld", (long long) nxids); elog(ERROR, "invalid nxids argument: %" PRId64, nxids);
if (nxids == 0) if (nxids == 0)
lastxid = ReadNextFullTransactionId(); lastxid = ReadNextFullTransactionId();
@ -56,8 +56,8 @@ consume_xids_until(PG_FUNCTION_ARGS)
FullTransactionId lastxid; FullTransactionId lastxid;
if (!FullTransactionIdIsNormal(targetxid)) if (!FullTransactionIdIsNormal(targetxid))
elog(ERROR, "targetxid %llu is not normal", elog(ERROR, "targetxid %" PRIu64 " is not normal",
(unsigned long long) U64FromFullTransactionId(targetxid)); U64FromFullTransactionId(targetxid));
lastxid = consume_xids_common(targetxid, 0); lastxid = consume_xids_common(targetxid, 0);
@ -136,8 +136,8 @@ consume_xids_common(FullTransactionId untilxid, uint64 nxids)
if (consumed - last_reported_at >= REPORT_INTERVAL) if (consumed - last_reported_at >= REPORT_INTERVAL)
{ {
if (nxids > 0) if (nxids > 0)
elog(NOTICE, "consumed %llu / %llu XIDs, latest %u:%u", elog(NOTICE, "consumed %" PRIu64 " / %" PRIu64 " XIDs, latest %u:%u",
(unsigned long long) consumed, (unsigned long long) nxids, consumed, nxids,
EpochFromFullTransactionId(lastxid), EpochFromFullTransactionId(lastxid),
XidFromFullTransactionId(lastxid)); XidFromFullTransactionId(lastxid));
else else