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

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

diff --git a/src/backend/access/brin/brin.c b/src/backend/access/brin/brin.c
index ba78ecff665eceddd93889a405ccfddc6c6594b0..43660107688e86ab0dae7b84251765db30054f61 100644 (file)
--- a/src/backend/access/brin/brin.c
+++ b/src/backend/access/brin/brin.c
@@ -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;
 
        /*

diff --git a/src/backend/commands/copyfrom.c b/src/backend/commands/copyfrom.c
index 7b3f5a84b82d07adebea16668cc4d57c1155f7ea..db6eb6fae7844ec2111710fd74b94b4de8bde05a 100644 (file)
--- a/src/backend/commands/copyfrom.c
+++ b/src/backend/commands/copyfrom.c
@@ -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);
                        }
                }
        }

diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c
index ab592ce2f153b8a82de32b574b652d0690adf9d5..c13cada3bf122954ae2bd837fb6d476732dabe32 100644 (file)
--- a/src/backend/commands/sequence.c
+++ b/src/backend/commands/sequence.c
@@ -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)

diff --git a/src/backend/utils/adt/xid8funcs.c b/src/backend/utils/adt/xid8funcs.c
index 60e57876de6a81a4a1f847cce22d160093e5af2b..6c57ec3d35820c4260b29a3e62b514b4d9acdaf9 100644 (file)
--- a/src/backend/utils/adt/xid8funcs.c
+++ b/src/backend/utils/adt/xid8funcs.c
@@ -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,

diff --git a/src/bin/pg_checksums/pg_checksums.c b/src/bin/pg_checksums/pg_checksums.c
index 7e69475947f64730be1a2d4a8115c40f25f9aa0e..5f0f5ee62d034320e388eece7677e98ce6fc3186 100644 (file)
--- a/src/bin/pg_checksums/pg_checksums.c
+++ b/src/bin/pg_checksums/pg_checksums.c
@@ -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);
                }
        }