open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove workarounds for avoiding [U]INT64_FORMAT in translatable strings.

Browse Source 
Further code simplification along the same lines as d914eb347
and earlier patches.

Aleksander Alekseev, Japin Li

Discussion: https://postgr.es/m/CAJ7c6TMSKi3Xs8h5MP38XOnQQpBLazJvVxVfPn++roitDJcR7g@mail.gmail.com
pull/81/head
Tom Lane 4 years ago
parent c540d37157
commit 1f8bc44868
5 changed files with 66 additions and 143 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 14
      src/backend/access/brin/brin.c
  2. 37
      src/backend/commands/copyfrom.c
  3. 126
      src/backend/commands/sequence.c
  4. 5
      src/backend/utils/adt/xid8funcs.c
  5. 27
      src/bin/pg_checksums/pg_checksums.c

14
src/backend/access/brin/brin.c
Unescape View File

@ -1017,13 +1017,10 @@ brin_summarize_range(PG_FUNCTION_ARGS)
errhint("BRIN control functions cannot be executed during recovery.")));
if (heapBlk64 > BRIN_ALL_BLOCKRANGES || heapBlk64 < 0)
{
char *blk = psprintf(INT64_FORMAT, heapBlk64);
ereport(ERROR,
(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
errmsg("block number out of range: %s", blk)));
}
errmsg("block number out of range: %lld",
(long long) heapBlk64)));
heapBlk = (BlockNumber) heapBlk64;
/*
@ -1094,13 +1091,10 @@ brin_desummarize_range(PG_FUNCTION_ARGS)
errhint("BRIN control functions cannot be executed during recovery.")));
if (heapBlk64 > MaxBlockNumber || heapBlk64 < 0)
{
char *blk = psprintf(INT64_FORMAT, heapBlk64);
ereport(ERROR,
(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
errmsg("block number out of range: %s", blk)));
}
errmsg("block number out of range: %lld",
(long long) heapBlk64)));
heapBlk = (BlockNumber) heapBlk64;
/*

37
src/backend/commands/copyfrom.c
Unescape View File

@ -115,21 +115,19 @@ void
CopyFromErrorCallback(void *arg)
{
CopyFromState cstate = (CopyFromState) arg;
char curlineno_str[32];
snprintf(curlineno_str, sizeof(curlineno_str), UINT64_FORMAT,
cstate->cur_lineno);
if (cstate->opts.binary)
{
/* can't usefully display the data */
if (cstate->cur_attname)
errcontext("COPY %s, line %s, column %s",
cstate->cur_relname, curlineno_str,
errcontext("COPY %s, line %llu, column %s",
cstate->cur_relname,
(unsigned long long) cstate->cur_lineno,
cstate->cur_attname);
else
errcontext("COPY %s, line %s",
cstate->cur_relname, curlineno_str);
errcontext("COPY %s, line %llu",
cstate->cur_relname,
(unsigned long long) cstate->cur_lineno);
}
else
{
@ -139,16 +137,19 @@ CopyFromErrorCallback(void *arg)
char *attval;
attval = limit_printout_length(cstate->cur_attval);
errcontext("COPY %s, line %s, column %s: \"%s\"",
cstate->cur_relname, curlineno_str,
cstate->cur_attname, attval);
errcontext("COPY %s, line %llu, column %s: \"%s\"",
cstate->cur_relname,
(unsigned long long) 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 %s, column %s: null input",
cstate->cur_relname, curlineno_str,
errcontext("COPY %s, line %llu, column %s: null input",
cstate->cur_relname,
(unsigned long long) cstate->cur_lineno,
cstate->cur_attname);
}
else
@ -163,14 +164,16 @@ CopyFromErrorCallback(void *arg)
char *lineval;
lineval = limit_printout_length(cstate->line_buf.data);
errcontext("COPY %s, line %s: \"%s\"",
cstate->cur_relname, curlineno_str, lineval);
errcontext("COPY %s, line %llu: \"%s\"",
cstate->cur_relname,
(unsigned long long) cstate->cur_lineno, lineval);
pfree(lineval);
}
else
{
errcontext("COPY %s, line %s",
cstate->cur_relname, curlineno_str);
errcontext("COPY %s, line %llu",
cstate->cur_relname,
(unsigned long long) cstate->cur_lineno);
}
}
}

126
src/backend/commands/sequence.c
Unescape View File

@ -706,15 +706,11 @@ nextval_internal(Oid relid, bool check_permissions)
if (rescnt > 0)
break; /* stop fetching */
if (!cycle)
{
char buf[100];
snprintf(buf, sizeof(buf), INT64_FORMAT, maxv);
ereport(ERROR,
(errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED),
errmsg("nextval: reached maximum value of sequence \"%s\" (%s)",
RelationGetRelationName(seqrel), buf)));
}
errmsg("nextval: reached maximum value of sequence \"%s\" (%lld)",
RelationGetRelationName(seqrel),
(long long) maxv)));
next = minv;
}
else
@ -729,15 +725,11 @@ nextval_internal(Oid relid, bool check_permissions)
if (rescnt > 0)
break; /* stop fetching */
if (!cycle)
{
char buf[100];
snprintf(buf, sizeof(buf), INT64_FORMAT, minv);
ereport(ERROR,
(errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED),
errmsg("nextval: reached minimum value of sequence \"%s\" (%s)",
RelationGetRelationName(seqrel), buf)));
}
errmsg("nextval: reached minimum value of sequence \"%s\" (%lld)",
RelationGetRelationName(seqrel),
(long long) minv)));
next = maxv;
}
else
@ -975,20 +967,11 @@ do_setval(Oid relid, int64 next, bool iscalled)
seq = read_seq_tuple(seqrel, &buf, &seqdatatuple);
if ((next < minv) || (next > maxv))
{
char bufv[100],
bufm[100],
bufx[100];
snprintf(bufv, sizeof(bufv), INT64_FORMAT, next);
snprintf(bufm, sizeof(bufm), INT64_FORMAT, minv);
snprintf(bufx, sizeof(bufx), INT64_FORMAT, maxv);
ereport(ERROR,
(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
errmsg("setval: value %s is out of bounds for sequence \"%s\" (%s..%s)",
bufv, RelationGetRelationName(seqrel),
bufm, bufx)));
}
errmsg("setval: value %lld is out of bounds for sequence \"%s\" (%lld..%lld)",
(long long) next, RelationGetRelationName(seqrel),
(long long) minv, (long long) maxv)));
/* Set the currval() state only if iscalled = true */
if (iscalled)
@ -1468,16 +1451,11 @@ init_params(ParseState *pstate, List *options, bool for_identity,
/* Validate maximum value. No need to check INT8 as seqmax is an int64 */
if ((seqform->seqtypid == INT2OID && (seqform->seqmax < PG_INT16_MIN || seqform->seqmax > PG_INT16_MAX))
|| (seqform->seqtypid == INT4OID && (seqform->seqmax < PG_INT32_MIN || seqform->seqmax > PG_INT32_MAX)))
{
char bufx[100];
snprintf(bufx, sizeof(bufx), INT64_FORMAT, seqform->seqmax);
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("MAXVALUE (%s) is out of range for sequence data type %s",
bufx, format_type_be(seqform->seqtypid))));
}
errmsg("MAXVALUE (%lld) is out of range for sequence data type %s",
(long long) seqform->seqmax,
format_type_be(seqform->seqtypid))));
/* MINVALUE (null arg means NO MINVALUE) */
if (min_value != NULL && min_value->arg)
@ -1505,30 +1483,19 @@ init_params(ParseState *pstate, List *options, bool for_identity,
/* Validate minimum value. No need to check INT8 as seqmin is an int64 */
if ((seqform->seqtypid == INT2OID && (seqform->seqmin < PG_INT16_MIN || seqform->seqmin > PG_INT16_MAX))
|| (seqform->seqtypid == INT4OID && (seqform->seqmin < PG_INT32_MIN || seqform->seqmin > PG_INT32_MAX)))
{
char bufm[100];
snprintf(bufm, sizeof(bufm), INT64_FORMAT, seqform->seqmin);
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("MINVALUE (%s) is out of range for sequence data type %s",
bufm, format_type_be(seqform->seqtypid))));
}
errmsg("MINVALUE (%lld) is out of range for sequence data type %s",
(long long) seqform->seqmin,
format_type_be(seqform->seqtypid))));
/* crosscheck min/max */
if (seqform->seqmin >= seqform->seqmax)
{
char bufm[100],
bufx[100];
snprintf(bufm, sizeof(bufm), INT64_FORMAT, seqform->seqmin);
snprintf(bufx, sizeof(bufx), INT64_FORMAT, seqform->seqmax);
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("MINVALUE (%s) must be less than MAXVALUE (%s)",
bufm, bufx)));
}
errmsg("MINVALUE (%lld) must be less than MAXVALUE (%lld)",
(long long) seqform->seqmin,
(long long) seqform->seqmax)));
/* START WITH */
if (start_value != NULL)
@ -1545,29 +1512,17 @@ init_params(ParseState *pstate, List *options, bool for_identity,
/* crosscheck START */
if (seqform->seqstart < seqform->seqmin)
{
char bufs[100],
bufm[100];
snprintf(bufs, sizeof(bufs), INT64_FORMAT, seqform->seqstart);
snprintf(bufm, sizeof(bufm), INT64_FORMAT, seqform->seqmin);
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("START value (%s) cannot be less than MINVALUE (%s)",
bufs, bufm)));
}
errmsg("START value (%lld) cannot be less than MINVALUE (%lld)",
(long long) seqform->seqstart,
(long long) seqform->seqmin)));
if (seqform->seqstart > seqform->seqmax)
{
char bufs[100],
bufm[100];
snprintf(bufs, sizeof(bufs), INT64_FORMAT, seqform->seqstart);
snprintf(bufm, sizeof(bufm), INT64_FORMAT, seqform->seqmax);
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("START value (%s) cannot be greater than MAXVALUE (%s)",
bufs, bufm)));
}
errmsg("START value (%lld) cannot be greater than MAXVALUE (%lld)",
(long long) seqform->seqstart,
(long long) seqform->seqmax)));
/* RESTART [WITH] */
if (restart_value != NULL)
@ -1587,44 +1542,27 @@ init_params(ParseState *pstate, List *options, bool for_identity,
/* crosscheck RESTART (or current value, if changing MIN/MAX) */
if (seqdataform->last_value < seqform->seqmin)
{
char bufs[100],
bufm[100];
snprintf(bufs, sizeof(bufs), INT64_FORMAT, seqdataform->last_value);
snprintf(bufm, sizeof(bufm), INT64_FORMAT, seqform->seqmin);
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("RESTART value (%s) cannot be less than MINVALUE (%s)",
bufs, bufm)));
}
errmsg("RESTART value (%lld) cannot be less than MINVALUE (%lld)",
(long long) seqdataform->last_value,
(long long) seqform->seqmin)));
if (seqdataform->last_value > seqform->seqmax)
{
char bufs[100],
bufm[100];
snprintf(bufs, sizeof(bufs), INT64_FORMAT, seqdataform->last_value);
snprintf(bufm, sizeof(bufm), INT64_FORMAT, seqform->seqmax);
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("RESTART value (%s) cannot be greater than MAXVALUE (%s)",
bufs, bufm)));
}
errmsg("RESTART value (%lld) cannot be greater than MAXVALUE (%lld)",
(long long) seqdataform->last_value,
(long long) seqform->seqmax)));
/* CACHE */
if (cache_value != NULL)
{
seqform->seqcache = defGetInt64(cache_value);
if (seqform->seqcache <= 0)
{
char buf[100];
snprintf(buf, sizeof(buf), INT64_FORMAT, seqform->seqcache);
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("CACHE (%s) must be greater than zero",
buf)));
}
errmsg("CACHE (%lld) must be greater than zero",
(long long) seqform->seqcache)));
seqdataform->log_cnt = 0;
}
else if (isInit)

5
src/backend/utils/adt/xid8funcs.c
Unescape View File

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

27
src/bin/pg_checksums/pg_checksums.c
Unescape View File

@ -132,8 +132,6 @@ static void
progress_report(bool finished)
{
int percent;
char total_size_str[32];
char current_size_str[32];
pg_time_t now;
Assert(showprogress);
@ -152,18 +150,9 @@ progress_report(bool finished)
/* Calculate current percentage of size done */
percent = total_size ? (int) ((current_size) * 100 / total_size) : 0;
/*
* Separate step to keep platform-dependent format code out of
* translatable strings. And we only test for INT64_FORMAT availability
* in snprintf, not fprintf.
*/
snprintf(total_size_str, sizeof(total_size_str), INT64_FORMAT,
total_size / (1024 * 1024));
snprintf(current_size_str, sizeof(current_size_str), INT64_FORMAT,
current_size / (1024 * 1024));
fprintf(stderr, _("%*s/%s MB (%d%%) computed"),
(int) strlen(current_size_str), current_size_str, total_size_str,
fprintf(stderr, _("%lld/%lld MB (%d%%) computed"),
(long long) (current_size / (1024 * 1024)),
(long long) (total_size / (1024 * 1024)),
percent);
/*
@ -657,11 +646,11 @@ main(int argc, char *argv[])
progress_report(true);
printf(_("Checksum operation completed\n"));
printf(_("Files scanned: %s\n"), psprintf(INT64_FORMAT, files_scanned));
printf(_("Blocks scanned: %s\n"), psprintf(INT64_FORMAT, blocks_scanned));
printf(_("Files scanned: %lld\n"), (long long) files_scanned);
printf(_("Blocks scanned: %lld\n"), (long long) blocks_scanned);
if (mode == PG_MODE_CHECK)
{
printf(_("Bad checksums: %s\n"), psprintf(INT64_FORMAT, badblocks));
printf(_("Bad checksums: %lld\n"), (long long) badblocks);
printf(_("Data checksum version: %u\n"), ControlFile->data_checksum_version);
if (badblocks > 0)
@ -669,8 +658,8 @@ main(int argc, char *argv[])
}
else if (mode == PG_MODE_ENABLE)
{
printf(_("Files written: %s\n"), psprintf(INT64_FORMAT, files_written));
printf(_("Blocks written: %s\n"), psprintf(INT64_FORMAT, blocks_written));
printf(_("Files written: %lld\n"), (long long) files_written);
printf(_("Blocks written: %lld\n"), (long long) blocks_written);
}
}

Write Preview
Loading…
Cancel
Save