cstate->num_errors > cstate->opts.reject_limit)
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
- errmsg("skipped more than REJECT_LIMIT (%lld) rows due to data type incompatibility",
- (long long) cstate->opts.reject_limit)));
+ errmsg("skipped more than REJECT_LIMIT (%" PRId64 ") rows due to data type incompatibility",
+ cstate->opts.reject_limit)));
/* Repeat NextCopyFrom() until no soft error occurs */
goto retry;
festate->cstate->num_errors > 0 &&
festate->cstate->opts.log_verbosity >= COPY_LOG_VERBOSITY_DEFAULT)
ereport(NOTICE,
- errmsg_plural("%llu row was skipped due to data type incompatibility",
- "%llu rows were skipped due to data type incompatibility",
- (unsigned long long) festate->cstate->num_errors,
- (unsigned long long) festate->cstate->num_errors));
+ errmsg_plural("%" PRIu64 " row was skipped due to data type incompatibility",
+ "%" PRIu64 " rows were skipped due to data type incompatibility",
+ festate->cstate->num_errors,
+ festate->cstate->num_errors));
EndCopyFrom(festate->cstate);
}
cstate->num_errors > 0 &&
cstate->opts.log_verbosity >= COPY_LOG_VERBOSITY_DEFAULT)
ereport(NOTICE,
- errmsg_plural("%llu row was skipped due to data type incompatibility",
- "%llu rows were skipped due to data type incompatibility",
- (unsigned long long) cstate->num_errors,
- (unsigned long long) cstate->num_errors));
+ errmsg_plural("%" PRIu64 " row was skipped due to data type incompatibility",
+ "%" PRIu64 " rows were skipped due to data type incompatibility",
+ cstate->num_errors,
+ cstate->num_errors));
EndCopyFrom(cstate);
if (blkno < 0 || blkno > MaxBlockNumber)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("invalid block number %lld",
- (long long) blkno)));
+ errmsg("invalid block number %" PRId64, blkno)));
if ((BlockNumber) (blkno) >= RelationGetNumberOfBlocks(rel))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("block number %lld is out of range",
- (long long) blkno)));
+ errmsg("block number %" PRId64 " is out of range", blkno)));
}
/* -----------------------------------------------
if (ovflblkno >= RelationGetNumberOfBlocks(indexRel))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("block number %lld is out of range for relation \"%s\"",
- (long long int) ovflblkno, RelationGetRelationName(indexRel))));
+ errmsg("block number %" PRId64 " is out of range for relation \"%s\"",
+ ovflblkno, RelationGetRelationName(indexRel))));
/* Read the metapage so we can determine which bitmap page to use */
metabuf = _hash_getbuf(indexRel, HASH_METAPAGE, HASH_READ, LH_META_PAGE);
if (first_block < 0 || first_block >= nblocks)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("starting block number must be between 0 and %lld",
- (long long) (nblocks - 1))));
+ errmsg("starting block number must be between 0 and %" PRId64,
+ (nblocks - 1))));
}
if (PG_ARGISNULL(4))
last_block = nblocks - 1;
if (last_block < 0 || last_block >= nblocks)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("ending block number must be between 0 and %lld",
- (long long) (nblocks - 1))));
+ errmsg("ending block number must be between 0 and %" PRId64,
+ (nblocks - 1))));
}
/* Now we're ready to do the real work. */
if (heapBlk64 > BRIN_ALL_BLOCKRANGES || heapBlk64 < 0)
ereport(ERROR,
(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
- errmsg("block number out of range: %lld",
- (long long) heapBlk64)));
+ errmsg("block number out of range: %" PRId64, heapBlk64)));
heapBlk = (BlockNumber) heapBlk64;
/*
if (heapBlk64 > MaxBlockNumber || heapBlk64 < 0)
ereport(ERROR,
(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
- errmsg("block number out of range: %lld",
- (long long) heapBlk64)));
+ errmsg("block number out of range: %" PRId64,
+ heapBlk64)));
heapBlk = (BlockNumber) heapBlk64;
/*
orig_rel_pages,
vacrel->eager_scanned_pages);
appendStringInfo(&buf,
- _("tuples: %lld removed, %lld remain, %lld are dead but not yet removable\n"),
- (long long) vacrel->tuples_deleted,
- (long long) vacrel->new_rel_tuples,
- (long long) vacrel->recently_dead_tuples);
+ _("tuples: %" PRId64 " removed, %" PRId64 " remain, %" PRId64 " are dead but not yet removable\n"),
+ vacrel->tuples_deleted,
+ (int64) vacrel->new_rel_tuples,
+ vacrel->recently_dead_tuples);
if (vacrel->missed_dead_tuples > 0)
appendStringInfo(&buf,
- _("tuples missed: %lld dead from %u pages not removed due to cleanup lock contention\n"),
- (long long) vacrel->missed_dead_tuples,
+ _("tuples missed: %" PRId64 " dead from %u pages not removed due to cleanup lock contention\n"),
+ vacrel->missed_dead_tuples,
vacrel->missed_dead_pages);
diff = (int32) (ReadNextTransactionId() -
vacrel->cutoffs.OldestXmin);
_("new relminmxid: %u, which is %d MXIDs ahead of previous value\n"),
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,
orig_rel_pages == 0 ? 100.0 :
100.0 * vacrel->new_frozen_tuple_pages /
orig_rel_pages,
- (long long) vacrel->tuples_frozen);
+ vacrel->tuples_frozen);
appendStringInfo(&buf,
_("visibility map: %u pages set all-visible, %u pages set all-frozen (%u were all-visible)\n"),
else
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
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,
vacrel->lpdead_item_pages,
orig_rel_pages == 0 ? 100.0 :
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++)
{
IndexBulkDeleteResult *istat = vacrel->indstats[i];
appendStringInfo(&buf, _("avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n"),
read_rate, write_rate);
appendStringInfo(&buf,
- _("buffer usage: %lld hits, %lld reads, %lld dirtied\n"),
- (long long) total_blks_hit,
- (long long) total_blks_read,
- (long long) total_blks_dirtied);
+ _("buffer usage: %" PRId64 " hits, %" PRId64 " reads, %" PRId64 " dirtied\n"),
+ total_blks_hit,
+ total_blks_read,
+ total_blks_dirtied);
appendStringInfo(&buf,
- _("WAL usage: %lld records, %lld full page images, %llu bytes, %lld buffers full\n"),
- (long long) walusage.wal_records,
- (long long) walusage.wal_fpi,
- (unsigned long long) walusage.wal_bytes,
- (long long) walusage.wal_buffers_full);
+ _("WAL usage: %" PRId64 " records, %" PRId64 " full page images, %" PRIu64 " bytes, %" PRId64 " buffers full\n"),
+ walusage.wal_records,
+ walusage.wal_fpi,
+ walusage.wal_bytes,
+ walusage.wal_buffers_full);
appendStringInfo(&buf, _("system usage: %s"), pg_rusage_show(&ru0));
ereport(verbose ? INFO : LOG,
vacuumed_pages == vacrel->lpdead_item_pages));
ereport(DEBUG2,
- (errmsg("table \"%s\": removed %lld dead item identifiers in %u pages",
- vacrel->relname, (long long) vacrel->dead_items_info->num_items,
+ (errmsg("table \"%s\": removed %" PRId64 " dead item identifiers in %u pages",
+ vacrel->relname, vacrel->dead_items_info->num_items,
vacuumed_pages)));
/* Revert to the previous phase information for error traceback */
int64 pageno;
memcpy(&pageno, rec, sizeof(pageno));
- appendStringInfo(buf, "page %lld", (long long) pageno);
+ appendStringInfo(buf, "page %" PRId64, pageno);
}
else if (info == CLOG_TRUNCATE)
{
xl_clog_truncate xlrec;
memcpy(&xlrec, rec, sizeof(xl_clog_truncate));
- appendStringInfo(buf, "page %lld; oldestXact %u",
- (long long) xlrec.pageno, xlrec.oldestXact);
+ appendStringInfo(buf, "page %" PRId64 "; oldestXact %u",
+ xlrec.pageno, xlrec.oldestXact);
}
}
int64 pageno;
memcpy(&pageno, rec, sizeof(pageno));
- appendStringInfo(buf, "%lld", (long long) pageno);
+ appendStringInfo(buf, "%" PRId64, pageno);
}
else if (info == COMMIT_TS_TRUNCATE)
{
xl_commit_ts_truncate *trunc = (xl_commit_ts_truncate *) rec;
- appendStringInfo(buf, "pageno %lld, oldestXid %u",
- (long long) trunc->pageno, trunc->oldestXid);
+ appendStringInfo(buf, "pageno %" PRId64 ", oldestXid %u",
+ trunc->pageno, trunc->oldestXid);
}
}
int64 pageno;
memcpy(&pageno, rec, sizeof(pageno));
- appendStringInfo(buf, "%lld", (long long) pageno);
+ appendStringInfo(buf, "%" PRId64, pageno);
}
else if (info == XLOG_MULTIXACT_CREATE_ID)
{
uint64 objid =
((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].dboid,
- (unsigned long long) objid);
+ objid);
}
}
}
*/
while (segment != endsegment)
{
- elog(DEBUG2, "truncating multixact members segment %llx",
- (unsigned long long) segment);
+ elog(DEBUG2, "truncating multixact members segment %" PRIx64,
+ segment);
SlruDeleteSegment(MultiXactMemberCtl, segment);
/* move to next segment, handling wraparound correctly */
}
elog(DEBUG1, "performing multixact truncation: "
- "offsets [%u, %u), offsets segments [%llx, %llx), "
- "members [%u, %u), members segments [%llx, %llx)",
+ "offsets [%u, %u), offsets segments [%" PRIx64 ", %" PRIx64 "), "
+ "members [%u, %u), members segments [%" PRIx64 ", %" PRIx64 ")",
oldestMulti, newOldestMulti,
- (unsigned long long) MultiXactIdToOffsetSegment(oldestMulti),
- (unsigned long long) MultiXactIdToOffsetSegment(newOldestMulti),
+ MultiXactIdToOffsetSegment(oldestMulti),
+ MultiXactIdToOffsetSegment(newOldestMulti),
oldestOffset, newOldestOffset,
- (unsigned long long) MXOffsetToMemberSegment(oldestOffset),
- (unsigned long long) MXOffsetToMemberSegment(newOldestOffset));
+ MXOffsetToMemberSegment(oldestOffset),
+ MXOffsetToMemberSegment(newOldestOffset));
/*
* Do truncation, and the WAL logging of the truncation, in a critical
SizeOfMultiXactTruncate);
elog(DEBUG1, "replaying multixact truncation: "
- "offsets [%u, %u), offsets segments [%llx, %llx), "
- "members [%u, %u), members segments [%llx, %llx)",
+ "offsets [%u, %u), offsets segments [%" PRIx64 ", %" PRIx64 "), "
+ "members [%u, %u), members segments [%" PRIx64 ", %" PRIx64 ")",
xlrec.startTruncOff, xlrec.endTruncOff,
- (unsigned long long) MultiXactIdToOffsetSegment(xlrec.startTruncOff),
- (unsigned long long) MultiXactIdToOffsetSegment(xlrec.endTruncOff),
+ MultiXactIdToOffsetSegment(xlrec.startTruncOff),
+ MultiXactIdToOffsetSegment(xlrec.endTruncOff),
xlrec.startTruncMemb, xlrec.endTruncMemb,
- (unsigned long long) MXOffsetToMemberSegment(xlrec.startTruncMemb),
- (unsigned long long) MXOffsetToMemberSegment(xlrec.endTruncMemb));
+ MXOffsetToMemberSegment(xlrec.startTruncMemb),
+ MXOffsetToMemberSegment(xlrec.endTruncMemb));
/* should not be required, but more than cheap enough */
LWLockAcquire(MultiXactTruncationLock, LW_EXCLUSIVE);
* that in the future we can't decrease SLRU_PAGES_PER_SEGMENT easily.
*/
Assert(segno >= 0 && segno <= INT64CONST(0xFFFFFFFFFFFFFFF));
- return snprintf(path, MAXPGPATH, "%s/%015llX", ctl->Dir,
- (long long) segno);
+ return snprintf(path, MAXPGPATH, "%s/%015" PRIX64, ctl->Dir, segno);
}
else
{
if (mainrdata_len > PG_UINT32_MAX)
ereport(ERROR,
(errmsg_internal("too much WAL data"),
- errdetail_internal("Main data length is %llu bytes for a maximum of %u bytes.",
- (unsigned long long) mainrdata_len,
+ errdetail_internal("Main data length is %" PRIu64 " bytes for a maximum of %u bytes.",
+ mainrdata_len,
PG_UINT32_MAX)));
mainrdata_len_4b = (uint32) mainrdata_len;
if (total_len > XLogRecordMaxSize)
ereport(ERROR,
(errmsg_internal("oversized WAL record"),
- errdetail_internal("WAL record would be %llu bytes (of maximum %u bytes); rmid %u flags %u.",
- (unsigned long long) total_len, XLogRecordMaxSize, rmid, info)));
+ errdetail_internal("WAL record would be %" PRIu64 " bytes (of maximum %u bytes); rmid %u flags %u.",
+ total_len, XLogRecordMaxSize, rmid, info)));
/*
* Fill in the fields in the record header. Prev-link is filled in later,
longhdr->xlp_sysid != state->system_identifier)
{
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",
- (unsigned long long) longhdr->xlp_sysid,
- (unsigned long long) state->system_identifier);
+ "WAL file is from different database system: WAL file database system identifier is %" PRIu64 ", pg_control database system identifier is %" PRIu64,
+ longhdr->xlp_sysid,
+ state->system_identifier);
return false;
}
else if (longhdr->xlp_seg_size != state->segcxt.ws_segsize)
if (manifest_system_identifier != system_identifier)
context->error_cb(context,
- "system identifier in backup manifest is %llu, but database system identifier is %llu",
- (unsigned long long) manifest_system_identifier,
- (unsigned long long) system_identifier);
+ "system identifier in backup manifest is %" PRIu64 ", but database system identifier is %" PRIu64,
+ manifest_system_identifier,
+ system_identifier);
}
/*
if (raw_tli < 1 || raw_tli > PG_INT32_MAX)
ereport(ERROR,
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. */
ws.tli = (TimeLineID) raw_tli;
ereport(LOG,
(errmsg("still searching for an unused OID in relation \"%s\"",
RelationGetRelationName(relation)),
- errdetail_plural("OID candidates have been checked %llu time, but no unused OID has been found yet.",
- "OID candidates have been checked %llu times, 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 %" PRIu64 " times, but no unused OID has been found yet.",
retries,
- (unsigned long long) retries)));
+ retries)));
/*
* Double the number of retries to do before logging next until it
if (retries > GETNEWOID_LOG_THRESHOLD)
{
ereport(LOG,
- (errmsg_plural("new OID has been assigned in relation \"%s\" after %llu retry",
- "new OID has been assigned in relation \"%s\" after %llu retries",
+ (errmsg_plural("new OID has been assigned in relation \"%s\" after %" PRIu64 " retry",
+ "new OID has been assigned in relation \"%s\" after %" PRIu64 " retries",
retries,
- RelationGetRelationName(relation), (unsigned long long) retries)));
+ RelationGetRelationName(relation), retries)));
}
return newOid;
}
appendStringInfo(&buf, _("avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n"),
read_rate, write_rate);
- appendStringInfo(&buf, _("buffer usage: %lld hits, %lld reads, %lld dirtied\n"),
- (long long) total_blks_hit,
- (long long) total_blks_read,
- (long long) total_blks_dirtied);
+ appendStringInfo(&buf, _("buffer usage: %" PRId64 " hits, %" PRId64 " reads, %" PRId64 " dirtied\n"),
+ total_blks_hit,
+ total_blks_read,
+ total_blks_dirtied);
appendStringInfo(&buf,
- _("WAL usage: %lld records, %lld full page images, %llu bytes, %lld buffers full\n"),
- (long long) walusage.wal_records,
- (long long) walusage.wal_fpi,
- (unsigned long long) walusage.wal_bytes,
- (long long) walusage.wal_buffers_full);
+ _("WAL usage: %" PRId64 " records, %" PRId64 " full page images, %" PRIu64 " bytes, %" PRId64 " buffers full\n"),
+ walusage.wal_records,
+ walusage.wal_fpi,
+ walusage.wal_bytes,
+ walusage.wal_buffers_full);
appendStringInfo(&buf, _("system usage: %s"), pg_rusage_show(&ru0));
ereport(verbose ? INFO : LOG,
if (reject_limit <= 0)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("REJECT_LIMIT (%lld) must be greater than zero",
- (long long) reject_limit)));
+ errmsg("REJECT_LIMIT (%" PRId64 ") must be greater than zero",
+ reject_limit)));
return reject_limit;
}
{
/* can't usefully display the data */
if (cstate->cur_attname)
- errcontext("COPY %s, line %llu, column %s",
+ errcontext("COPY %s, line %" PRIu64 ", column %s",
cstate->cur_relname,
- (unsigned long long) cstate->cur_lineno,
+ cstate->cur_lineno,
cstate->cur_attname);
else
- errcontext("COPY %s, line %llu",
+ errcontext("COPY %s, line %" PRIu64,
cstate->cur_relname,
- (unsigned long long) cstate->cur_lineno);
+ cstate->cur_lineno);
}
else
{
char *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,
- (unsigned long long) cstate->cur_lineno,
+ cstate->cur_lineno,
cstate->cur_attname,
attval);
pfree(attval);
else if (cstate->cur_attname)
{
/* 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,
- (unsigned long long) cstate->cur_lineno,
+ cstate->cur_lineno,
cstate->cur_attname);
}
else
char *lineval;
lineval = CopyLimitPrintoutLength(cstate->line_buf.data);
- errcontext("COPY %s, line %llu: \"%s\"",
+ errcontext("COPY %s, line %" PRIu64 ": \"%s\"",
cstate->cur_relname,
- (unsigned long long) cstate->cur_lineno, lineval);
+ cstate->cur_lineno, lineval);
pfree(lineval);
}
else
{
- errcontext("COPY %s, line %llu",
+ errcontext("COPY %s, line %" PRIu64,
cstate->cur_relname,
- (unsigned long long) cstate->cur_lineno);
+ cstate->cur_lineno);
}
}
}
cstate->num_errors > cstate->opts.reject_limit)
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
- errmsg("skipped more than REJECT_LIMIT (%lld) rows due to data type incompatibility",
- (long long) cstate->opts.reject_limit)));
+ errmsg("skipped more than REJECT_LIMIT (%" PRId64 ") rows due to data type incompatibility",
+ cstate->opts.reject_limit)));
/* Repeat NextCopyFrom() until no soft error occurs */
continue;
cstate->num_errors > 0 &&
cstate->opts.log_verbosity >= COPY_LOG_VERBOSITY_DEFAULT)
ereport(NOTICE,
- errmsg_plural("%llu row was skipped due to data type incompatibility",
- "%llu rows were skipped due to data type incompatibility",
- (unsigned long long) cstate->num_errors,
- (unsigned long long) cstate->num_errors));
+ errmsg_plural("%" PRIu64 " row was skipped due to data type incompatibility",
+ "%" PRIu64 " rows were skipped due to data type incompatibility",
+ cstate->num_errors,
+ cstate->num_errors));
if (bistate != NULL)
FreeBulkInsertState(bistate);
attval = CopyLimitPrintoutLength(cstate->cur_attval);
ereport(NOTICE,
- errmsg("skipping row due to data type incompatibility at line %llu for column \"%s\": \"%s\"",
- (unsigned long long) cstate->cur_lineno,
+ errmsg("skipping row due to data type incompatibility at line %" PRIu64 " for column \"%s\": \"%s\"",
+ cstate->cur_lineno,
cstate->cur_attname,
attval));
pfree(attval);
}
else
ereport(NOTICE,
- errmsg("skipping row due to data type incompatibility at line %llu for column \"%s\": null input",
- (unsigned long long) cstate->cur_lineno,
+ errmsg("skipping row due to data type incompatibility at line %" PRIu64 " for column \"%s\": null input",
+ cstate->cur_lineno,
cstate->cur_attname));
/* reset relname_only */
{
appendStringInfoString(es->str, " shared");
if (usage->shared_blks_hit > 0)
- appendStringInfo(es->str, " hit=%lld",
- (long long) usage->shared_blks_hit);
+ appendStringInfo(es->str, " hit=%" PRId64,
+ usage->shared_blks_hit);
if (usage->shared_blks_read > 0)
- appendStringInfo(es->str, " read=%lld",
- (long long) usage->shared_blks_read);
+ appendStringInfo(es->str, " read=%" PRId64,
+ usage->shared_blks_read);
if (usage->shared_blks_dirtied > 0)
- appendStringInfo(es->str, " dirtied=%lld",
- (long long) usage->shared_blks_dirtied);
+ appendStringInfo(es->str, " dirtied=%" PRId64,
+ usage->shared_blks_dirtied);
if (usage->shared_blks_written > 0)
- appendStringInfo(es->str, " written=%lld",
- (long long) usage->shared_blks_written);
+ appendStringInfo(es->str, " written=%" PRId64,
+ usage->shared_blks_written);
if (has_local || has_temp)
appendStringInfoChar(es->str, ',');
}
{
appendStringInfoString(es->str, " local");
if (usage->local_blks_hit > 0)
- appendStringInfo(es->str, " hit=%lld",
- (long long) usage->local_blks_hit);
+ appendStringInfo(es->str, " hit=%" PRId64,
+ usage->local_blks_hit);
if (usage->local_blks_read > 0)
- appendStringInfo(es->str, " read=%lld",
- (long long) usage->local_blks_read);
+ appendStringInfo(es->str, " read=%" PRId64,
+ usage->local_blks_read);
if (usage->local_blks_dirtied > 0)
- appendStringInfo(es->str, " dirtied=%lld",
- (long long) usage->local_blks_dirtied);
+ appendStringInfo(es->str, " dirtied=%" PRId64,
+ usage->local_blks_dirtied);
if (usage->local_blks_written > 0)
- appendStringInfo(es->str, " written=%lld",
- (long long) usage->local_blks_written);
+ appendStringInfo(es->str, " written=%" PRId64,
+ usage->local_blks_written);
if (has_temp)
appendStringInfoChar(es->str, ',');
}
{
appendStringInfoString(es->str, " temp");
if (usage->temp_blks_read > 0)
- appendStringInfo(es->str, " read=%lld",
- (long long) usage->temp_blks_read);
+ appendStringInfo(es->str, " read=%" PRId64,
+ usage->temp_blks_read);
if (usage->temp_blks_written > 0)
- appendStringInfo(es->str, " written=%lld",
- (long long) usage->temp_blks_written);
+ appendStringInfo(es->str, " written=%" PRId64,
+ usage->temp_blks_written);
}
appendStringInfoChar(es->str, '\n');
}
appendStringInfoString(es->str, "WAL:");
if (usage->wal_records > 0)
- appendStringInfo(es->str, " records=%lld",
- (long long) usage->wal_records);
+ appendStringInfo(es->str, " records=%" PRId64,
+ usage->wal_records);
if (usage->wal_fpi > 0)
- appendStringInfo(es->str, " fpi=%lld",
- (long long) usage->wal_fpi);
+ appendStringInfo(es->str, " fpi=%" PRId64,
+ usage->wal_fpi);
if (usage->wal_bytes > 0)
- appendStringInfo(es->str, " bytes=" UINT64_FORMAT,
+ appendStringInfo(es->str, " bytes=%" PRIu64,
usage->wal_bytes);
if (usage->wal_buffers_full > 0)
- appendStringInfo(es->str, " buffers full=%lld",
- (long long) usage->wal_buffers_full);
+ appendStringInfo(es->str, " buffers full=%" PRId64,
+ usage->wal_buffers_full);
appendStringInfoChar(es->str, '\n');
}
}
if (!cycle)
ereport(ERROR,
(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),
- (long long) maxv)));
+ maxv)));
next = minv;
}
else
if (!cycle)
ereport(ERROR,
(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),
- (long long) minv)));
+ minv)));
next = maxv;
}
else
if ((next < minv) || (next > maxv))
ereport(ERROR,
(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
- errmsg("setval: value %lld is out of bounds for sequence \"%s\" (%lld..%lld)",
- (long long) next, RelationGetRelationName(seqrel),
- (long long) minv, (long long) maxv)));
+ errmsg("setval: value %" PRId64 " is out of bounds for sequence \"%s\" (%" PRId64 "..%" PRId64 ")",
+ next, RelationGetRelationName(seqrel),
+ minv, maxv)));
/* Set the currval() state only if iscalled = true */
if (iscalled)
|| (seqform->seqtypid == INT4OID && (seqform->seqmax < PG_INT32_MIN || seqform->seqmax > PG_INT32_MAX)))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("MAXVALUE (%lld) is out of range for sequence data type %s",
- (long long) seqform->seqmax,
+ errmsg("MAXVALUE (%" PRId64 ") is out of range for sequence data type %s",
+ seqform->seqmax,
format_type_be(seqform->seqtypid))));
/* MINVALUE (null arg means NO MINVALUE) */
|| (seqform->seqtypid == INT4OID && (seqform->seqmin < PG_INT32_MIN || seqform->seqmin > PG_INT32_MAX)))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("MINVALUE (%lld) is out of range for sequence data type %s",
- (long long) seqform->seqmin,
+ errmsg("MINVALUE (%" PRId64 ") is out of range for sequence data type %s",
+ seqform->seqmin,
format_type_be(seqform->seqtypid))));
/* crosscheck min/max */
if (seqform->seqmin >= seqform->seqmax)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("MINVALUE (%lld) must be less than MAXVALUE (%lld)",
- (long long) seqform->seqmin,
- (long long) seqform->seqmax)));
+ errmsg("MINVALUE (%" PRId64 ") must be less than MAXVALUE (%" PRId64 ")",
+ seqform->seqmin,
+ seqform->seqmax)));
/* START WITH */
if (start_value != NULL)
if (seqform->seqstart < seqform->seqmin)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("START value (%lld) cannot be less than MINVALUE (%lld)",
- (long long) seqform->seqstart,
- (long long) seqform->seqmin)));
+ errmsg("START value (%" PRId64 ") cannot be less than MINVALUE (%" PRId64 ")",
+ seqform->seqstart,
+ seqform->seqmin)));
if (seqform->seqstart > seqform->seqmax)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("START value (%lld) cannot be greater than MAXVALUE (%lld)",
- (long long) seqform->seqstart,
- (long long) seqform->seqmax)));
+ errmsg("START value (%" PRId64 ") cannot be greater than MAXVALUE (%" PRId64 ")",
+ seqform->seqstart,
+ seqform->seqmax)));
/* RESTART [WITH] */
if (restart_value != NULL)
if (seqdataform->last_value < seqform->seqmin)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("RESTART value (%lld) cannot be less than MINVALUE (%lld)",
- (long long) seqdataform->last_value,
- (long long) seqform->seqmin)));
+ errmsg("RESTART value (%" PRId64 ") cannot be less than MINVALUE (%" PRId64 ")",
+ seqdataform->last_value,
+ seqform->seqmin)));
if (seqdataform->last_value > seqform->seqmax)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("RESTART value (%lld) cannot be greater than MAXVALUE (%lld)",
- (long long) seqdataform->last_value,
- (long long) seqform->seqmax)));
+ errmsg("RESTART value (%" PRId64 ") cannot be greater than MAXVALUE (%" PRId64 ")",
+ seqdataform->last_value,
+ seqform->seqmax)));
/* CACHE */
if (cache_value != NULL)
if (seqform->seqcache <= 0)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("CACHE (%lld) must be greater than zero",
- (long long) seqform->seqcache)));
+ errmsg("CACHE (%" PRId64 ") must be greater than zero",
+ seqform->seqcache)));
seqdataform->log_cnt = 0;
}
else if (isInit)
dead_items);
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),
- (long long) dead_items_info->num_items)));
+ dead_items_info->num_items)));
return istat;
}
if (rb->spillBytes <= 0 && rb->streamBytes <= 0 && rb->totalBytes <= 0)
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,
- (long long) rb->spillTxns,
- (long long) rb->spillCount,
- (long long) rb->spillBytes,
- (long long) rb->streamTxns,
- (long long) rb->streamCount,
- (long long) rb->streamBytes,
- (long long) rb->totalTxns,
- (long long) rb->totalBytes);
+ rb->spillTxns,
+ rb->spillCount,
+ rb->spillBytes,
+ rb->streamTxns,
+ rb->streamCount,
+ rb->streamBytes,
+ rb->totalTxns,
+ rb->totalBytes);
repSlotStat.spill_txns = rb->spillTxns;
repSlotStat.spill_count = rb->spillCount;
{
case RS_INVAL_WAL_REMOVED:
{
- unsigned long long ex = oldestLSN - restart_lsn;
+ uint64 ex = oldestLSN - restart_lsn;
appendStringInfo(&err_detail,
- ngettext("The slot's restart_lsn %X/%X exceeds the limit by %llu byte.",
- "The slot's restart_lsn %X/%X exceeds the limit by %llu bytes.",
+ 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 %" PRIu64 " bytes.",
ex),
LSN_FORMAT_ARGS(restart_lsn),
ex);
before_shmem_exit_list[before_shmem_exit_index - 1].arg == arg)
--before_shmem_exit_index;
else
- elog(ERROR, "before_shmem_exit callback (%p,0x%llx) is not the latest entry",
- function, (long long) arg);
+ elog(ERROR, "before_shmem_exit callback (%p,0x%" PRIxPTR ") is not the latest entry",
+ function, arg);
}
/* ----------------------------------------------------------------
} while (remainingtime > 0);
ereport(WARNING,
- (errmsg_plural("backend with PID %d did not terminate within %lld millisecond",
- "backend with PID %d did not terminate within %lld milliseconds",
+ (errmsg_plural("backend with PID %d did not terminate within %" PRId64 " millisecond",
+ "backend with PID %d did not terminate within %" PRId64 " milliseconds",
timeout,
- pid, (long long int) timeout)));
+ pid, timeout)));
return false;
}
*/
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,
- (unsigned long long) ps->key.objid);
+ ps->key.objid);
continue;
}
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,
- (unsigned long long) key.objid, t);
+ key.objid, t);
goto error;
}
}
if (found)
{
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,
- (unsigned long long) key.objid, t);
+ key.objid, t);
goto error;
}
pgstat_get_entry_data(key.kind, header),
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,
- (unsigned long long) key.objid, t);
+ key.objid, t);
goto error;
}
* at the offset.
*/
if (!ReplicationSlotName(key->objid, name))
- elog(ERROR, "could not find name for replication slot index %llu",
- (unsigned long long) key->objid);
+ elog(ERROR, "could not find name for replication slot index %" PRIu64,
+ key->objid);
}
bool
*/
if (shent->dropped)
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,
shent->key.dboid,
- (unsigned long long) shent->key.objid,
+ shent->key.objid,
pg_atomic_read_u32(&shent->refcount));
shent->dropped = true;
if (pgstat_get_entry_ref(kind, dboid, objid, false, NULL))
{
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,
- (unsigned long long) objid));
+ objid));
pgstat_reset(kind, dboid, objid);
}
{
if (value == 0)
return cp;
- sprintf(cp, "%lld%c", (long long) value, units);
+ sprintf(cp, "%" PRId64 "%c", value, units);
return cp + strlen(cp);
}
{
if (value == 0)
return cp;
- sprintf(cp, "%s%s%lld %s%s",
+ sprintf(cp, "%s%s%" PRId64 " %s%s",
(!*is_zero) ? " " : "",
(*is_before && value > 0) ? "+" : "",
- (long long) value,
+ value,
units,
(value != 1) ? "s" : "");
}
else if (*is_before)
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;
return cp + strlen(cp);
}
char sec_sign = (hour < 0 || min < 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),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
+ day_sign, i64abs(mday),
+ sec_sign, i64abs(hour), abs(min));
cp += strlen(cp);
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
+ sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ mday, hour, min);
cp += strlen(cp);
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ sprintf(cp, "%" PRId64 ":%02d:", hour, min);
cp += strlen(cp);
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\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 ? "" : " ",
(minus ? "-" : (is_before ? "+" : "")),
- (long long) i64abs(hour), abs(min));
+ i64abs(hour), abs(min));
cp += strlen(cp);
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
if (n < 0 || n >= (int64) len * 8)
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
- errmsg("index %lld out of valid range, 0..%lld",
- (long long) n, (long long) len * 8 - 1)));
+ errmsg("index %" PRId64 " out of valid range, 0..%" PRId64,
+ n, (int64) len * 8 - 1)));
/* n/8 is now known < len, so safe to cast to int */
byteNo = (int) (n / 8);
if (n < 0 || n >= (int64) len * 8)
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
- errmsg("index %lld out of valid range, 0..%lld",
- (long long) n, (long long) len * 8 - 1)));
+ errmsg("index %" PRId64 " out of valid range, 0..%" PRId64,
+ n, (int64) len * 8 - 1)));
/* n/8 is now known < len, so safe to cast to int */
byteNo = (int) (n / 8);
if (!FullTransactionIdPrecedes(fxid, now_fullxid))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("transaction ID %llu is in the future",
- (unsigned long long) U64FromFullTransactionId(fxid))));
+ errmsg("transaction ID %" PRIu64 " is in the future",
+ U64FromFullTransactionId(fxid))));
/*
* TransamVariables->oldestClogXid is protected by XactTruncationLock, but
appendStringInfoChar(&buf, ',');
/* query id */
- appendStringInfo(&buf, "%lld", (long long) pgstat_get_my_query_id());
+ appendStringInfo(&buf, "%" PRId64, pgstat_get_my_query_id());
appendStringInfoChar(&buf, '\n');
break;
case 'Q':
if (padding != 0)
- appendStringInfo(buf, "%*lld", padding,
- (long long) pgstat_get_my_query_id());
+ appendStringInfo(buf, "%*" PRId64, padding,
+ pgstat_get_my_query_id());
else
- appendStringInfo(buf, "%lld",
- (long long) pgstat_get_my_query_id());
+ appendStringInfo(buf, "%" PRId64,
+ pgstat_get_my_query_id());
break;
default:
/* format error - ignore it */
}
/* query id */
- appendJSONKeyValueFmt(&buf, "query_id", false, "%lld",
- (long long) pgstat_get_my_query_id());
+ appendJSONKeyValueFmt(&buf, "query_id", false, "%" PRId64,
+ pgstat_get_my_query_id());
/* Finish string */
appendStringInfoChar(&buf, '}');
static void
BogusFree(void *pointer)
{
- elog(ERROR, "pfree called with invalid pointer %p (header 0x%016llx)",
- pointer, (unsigned long long) GetMemoryChunkHeader(pointer));
+ elog(ERROR, "pfree called with invalid pointer %p (header 0x%016" PRIx64 ")",
+ pointer, GetMemoryChunkHeader(pointer));
}
static void *
BogusRealloc(void *pointer, Size size, int flags)
{
- elog(ERROR, "repalloc called with invalid pointer %p (header 0x%016llx)",
- pointer, (unsigned long long) GetMemoryChunkHeader(pointer));
+ elog(ERROR, "repalloc called with invalid pointer %p (header 0x%016" PRIx64 ")",
+ pointer, GetMemoryChunkHeader(pointer));
return NULL; /* keep compiler quiet */
}
static MemoryContext
BogusGetChunkContext(void *pointer)
{
- elog(ERROR, "GetMemoryChunkContext called with invalid pointer %p (header 0x%016llx)",
- pointer, (unsigned long long) GetMemoryChunkHeader(pointer));
+ elog(ERROR, "GetMemoryChunkContext called with invalid pointer %p (header 0x%016" PRIx64 ")",
+ pointer, GetMemoryChunkHeader(pointer));
return NULL; /* keep compiler quiet */
}
static Size
BogusGetChunkSpace(void *pointer)
{
- elog(ERROR, "GetMemoryChunkSpace called with invalid pointer %p (header 0x%016llx)",
- pointer, (unsigned long long) GetMemoryChunkHeader(pointer));
+ elog(ERROR, "GetMemoryChunkSpace called with invalid pointer %p (header 0x%016" PRIx64 ")",
+ pointer, GetMemoryChunkHeader(pointer));
return 0; /* keep compiler quiet */
}
if (BufFileSeekBlock(lts->pfile, blocknum) != 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not seek to block %lld of temporary file",
- (long long) blocknum)));
+ errmsg("could not seek to block %" PRId64 " of temporary file",
+ blocknum)));
BufFileWrite(lts->pfile, buffer, BLCKSZ);
/* Update nBlocksWritten, if we extended the file */
if (BufFileSeekBlock(lts->pfile, blocknum) != 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not seek to block %lld of temporary file",
- (long long) blocknum)));
+ errmsg("could not seek to block %" PRId64 " of temporary file",
+ blocknum)));
BufFileReadExact(lts->pfile, buffer, BLCKSZ);
}
ltsReadBlock(lt->tapeSet, prev, lt->buffer);
if (TapeBlockGetTrailer(lt->buffer)->next != lt->curBlockNumber)
- elog(ERROR, "broken tape, next of block %lld is %lld, expected %lld",
- (long long) prev,
- (long long) (TapeBlockGetTrailer(lt->buffer)->next),
- (long long) lt->curBlockNumber);
+ elog(ERROR, "broken tape, next of block %" PRId64 " is %" PRId64 ", expected %" PRId64,
+ prev,
+ TapeBlockGetTrailer(lt->buffer)->next,
+ lt->curBlockNumber);
lt->nbytes = TapeBlockPayloadSize;
lt->curBlockNumber = prev;
if (trace_sort)
{
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",
- state->worker, (long long) spaceUsed, pg_rusage_show(&state->ru_start));
+ state->worker, spaceUsed, pg_rusage_show(&state->ru_start));
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",
- 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);
sysid = strtou64(PQgetvalue(res, 0, 0), NULL, 10);
- pg_log_info("system identifier is %llu on publisher",
- (unsigned long long) sysid);
+ pg_log_info("system identifier is %" PRIu64 " on publisher", sysid);
PQclear(res);
disconnect_database(conn, false);
sysid = cf->system_identifier;
- pg_log_info("system identifier is %llu on subscriber",
- (unsigned long long) sysid);
+ pg_log_info("system identifier is %" PRIu64 " on subscriber", sysid);
pg_free(cf);
if (!dry_run)
update_controlfile(subscriber_dir, cf, true);
- pg_log_info("system identifier is %llu on subscriber",
- (unsigned long long) cf->system_identifier);
+ pg_log_info("system identifier is %" PRIu64 " on subscriber",
+ cf->system_identifier);
pg_log_info("running pg_resetwal on the subscriber");
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,
- (unsigned long long) manifests[i]->system_identifier,
- (unsigned long long) system_identifier);
+ manifests[i]->system_identifier,
+ system_identifier);
}
}
if (i == n_backups - 1)
system_identifier = control_file->system_identifier;
else if (system_identifier != control_file->system_identifier)
- pg_fatal("%s: expected system identifier %llu, but found %llu",
- controlpath, (unsigned long long) system_identifier,
- (unsigned long long) control_file->system_identifier);
+ pg_fatal("%s: expected system identifier %" PRIu64 ", but found %" PRIu64,
+ controlpath, system_identifier,
+ control_file->system_identifier);
/*
* Detect checksum mismatches, but only if the last backup in the
* If debug output is enabled, make a note of the system identifier that
* we found in all of the relevant control files.
*/
- pg_log_debug("system identifier is %llu",
- (unsigned long long) system_identifier);
+ pg_log_debug("system identifier is %" PRIu64, system_identifier);
/*
* Warn the user if not all backups are in the same state with regards to
appendStringInfoString(&mwriter->buf, "\", ");
}
- appendStringInfo(&mwriter->buf, "\"Size\": %llu, ",
- (unsigned long long) size);
+ appendStringInfo(&mwriter->buf, "\"Size\": %" PRIu64 ", ", size);
appendStringInfoString(&mwriter->buf, "\"Last-Modified\": \"");
enlargeStringInfo(&mwriter->buf, 128);
ControlFile->pg_control_version);
printf(_("Catalog version number: %u\n"),
ControlFile->catalog_version_no);
- printf(_("Database system identifier: %llu\n"),
- (unsigned long long) ControlFile->system_identifier);
+ printf(_("Database system identifier: %" PRIu64 "\n"),
+ ControlFile->system_identifier);
printf(_("Database cluster state: %s\n"),
dbState(ControlFile->state));
printf(_("pg_control last modified: %s\n"),
ControlFile.pg_control_version);
printf(_("Catalog version number: %u\n"),
ControlFile.catalog_version_no);
- printf(_("Database system identifier: %llu\n"),
- (unsigned long long) ControlFile.system_identifier);
+ printf(_("Database system identifier: %" PRIu64 "\n"),
+ ControlFile.system_identifier);
printf(_("Latest checkpoint's TimeLineID: %u\n"),
ControlFile.checkPointCopy.ThisTimeLineID);
printf(_("Latest checkpoint's full_page_writes: %s\n"),
}
else
{
- pg_log_debug("received chunk for file \"%s\", offset %lld, size %d",
- filename, (long long int) chunkoff, chunksize);
+ pg_log_debug("received chunk for file \"%s\", offset %" PRId64 ", size %d",
+ filename, chunkoff, chunksize);
if (strcmp(filename, rq->path) != 0)
{
filename, rq->path);
}
if (chunkoff != rq->offset)
- pg_fatal("received data at offset %lld of file \"%s\", when requested for offset %lld",
- (long long int) chunkoff, rq->path, (long long int) rq->offset);
+ pg_fatal("received data at offset %" PRId64 " of file \"%s\", when requested for offset %lld",
+ chunkoff, rq->path, (long long int) rq->offset);
/*
* We should not receive more data than we requested, or
if (m->size != member->size)
{
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,
(unsigned long long) member->size,
mystreamer->archive_name,
- (unsigned long long) m->size);
+ m->size);
m->bad = true;
return;
}
if (mystreamer->checksum_bytes != m->size)
{
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,
- (unsigned long long) m->size,
- (unsigned long long) mystreamer->checksum_bytes);
+ m->size,
+ mystreamer->checksum_bytes);
return;
}
/* System identifiers should match. */
if (manifest->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->mfile->pathname,
- (unsigned long long) manifest->system_identifier,
- (unsigned long long) mystreamer->control_file.system_identifier);
+ manifest->system_identifier,
+ mystreamer->control_file.system_identifier);
}
/*
/* System identifiers should match. */
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,
- (unsigned long long) manifest_system_identifier,
- (unsigned long long) control_file->system_identifier);
+ manifest_system_identifier,
+ control_file->system_identifier);
/* Release memory. */
pfree(control_file);
if (bytes_read != m->size)
{
report_backup_error(context,
- "file \"%s\" should contain %llu bytes, but read %llu bytes",
- relpath, (unsigned long long) m->size,
- (unsigned long long) bytes_read);
+ "file \"%s\" should contain %" PRIu64 " bytes, but read %" PRIu64,
+ relpath, m->size, bytes_read);
return;
}
/* Catch possible overflow. Using >= here allows adding 1 below */
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"),
- (long long int) total_cells,
- (long long int) (SIZE_MAX / sizeof(*content->cells)));
+ fprintf(stderr, _("Cannot print table contents: number of cells %" PRId64 " is equal to or exceeds maximum %zu.\n"),
+ total_cells,
+ SIZE_MAX / sizeof(*content->cells));
exit(EXIT_FAILURE);
}
content->cells = pg_malloc0((total_cells + 1) * sizeof(*content->cells));
total_cells = (uint64) content->ncolumns * content->nrows;
if (content->cellsadded >= total_cells)
{
- fprintf(stderr, _("Cannot add cell to table content: total cell count of %lld exceeded.\n"),
- (long long int) total_cells);
+ fprintf(stderr, _("Cannot add cell to table content: total cell count of %" PRId64 " exceeded.\n"),
+ total_cells);
exit(EXIT_FAILURE);
}
RT_STATS(RT_RADIX_TREE * tree)
{
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
fprintf(stderr, "handle = " DSA_POINTER_FORMAT "\n", tree->ctl->handle);
{
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");
}
processed = DoCopyTo(cstate);
EndCopyTo(cstate);
- ereport(NOTICE, (errmsg("COPY TO callback has processed %lld rows",
- (long long) processed)));
+ ereport(NOTICE, (errmsg("COPY TO callback has processed %" PRId64 " rows",
+ processed)));
table_close(rel, NoLock);
ftag.segno = pageno / SLRU_PAGES_PER_SEGMENT;
SlruSyncFileTag(TestSlruCtl, &ftag, path);
- elog(NOTICE, "Called SlruSyncFileTag() for segment %lld on path %s",
- (long long) ftag.segno, path);
+ elog(NOTICE, "Called SlruSyncFileTag() for segment %" PRId64 " on path %s",
+ ftag.segno, path);
PG_RETURN_VOID();
}
ftag.segno = pageno / SLRU_PAGES_PER_SEGMENT;
SlruDeleteSegment(TestSlruCtl, ftag.segno);
- elog(NOTICE, "Called SlruDeleteSegment() for segment %lld",
- (long long) ftag.segno);
+ elog(NOTICE, "Called SlruDeleteSegment() for segment %" PRId64,
+ ftag.segno);
PG_RETURN_VOID();
}
FullTransactionId lastxid;
if (nxids < 0)
- elog(ERROR, "invalid nxids argument: %lld", (long long) nxids);
+ elog(ERROR, "invalid nxids argument: %" PRId64, nxids);
if (nxids == 0)
lastxid = ReadNextFullTransactionId();
FullTransactionId lastxid;
if (!FullTransactionIdIsNormal(targetxid))
- elog(ERROR, "targetxid %llu is not normal",
- (unsigned long long) U64FromFullTransactionId(targetxid));
+ elog(ERROR, "targetxid %" PRIu64 " is not normal",
+ U64FromFullTransactionId(targetxid));
lastxid = consume_xids_common(targetxid, 0);
if (consumed - last_reported_at >= REPORT_INTERVAL)
{
if (nxids > 0)
- elog(NOTICE, "consumed %llu / %llu XIDs, latest %u:%u",
- (unsigned long long) consumed, (unsigned long long) nxids,
+ elog(NOTICE, "consumed %" PRIu64 " / %" PRIu64 " XIDs, latest %u:%u",
+ consumed, nxids,
EpochFromFullTransactionId(lastxid),
XidFromFullTransactionId(lastxid));
else
projects / postgresql.git / commitdiff