pg_size_pretty: Format negative values similar to positive ones.

Previously, negative values were always displayed in bytes, regardless
of how large they were.

Adrian Vondendriesch, reviewed by Julien Rouhaud and myself

diff --git a/src/backend/utils/adt/dbsize.c b/src/backend/utils/adt/dbsize.c
index 82311b4ca95a87a010b748eca6151defa9562725..5ee59d0a2e250be6990131a2e1a6f980754b7346 100644 (file)
--- a/src/backend/utils/adt/dbsize.c
+++ b/src/backend/utils/adt/dbsize.c
@@ -31,6 +31,8 @@
 #include "utils/relmapper.h"
 #include "utils/syscache.h"
 
+/* Divide by two and round towards positive infinity. */
+#define half_rounded(x)   (((x) + ((x) < 0 ? 0 : 1)) / 2)
 
 /* Return physical size of directory contents, or 0 if dir doesn't exist */
 static int64
@@ -534,31 +536,31 @@ pg_size_pretty(PG_FUNCTION_ARGS)
        int64           limit = 10 * 1024;
        int64           limit2 = limit * 2 - 1;
 
-       if (size < limit)
+       if (Abs(size) < limit)
                snprintf(buf, sizeof(buf), INT64_FORMAT " bytes", size);
        else
        {
                size >>= 9;                             /* keep one extra bit for rounding */
-               if (size < limit2)
+               if (Abs(size) < limit2)
                        snprintf(buf, sizeof(buf), INT64_FORMAT " kB",
-                                        (size + 1) / 2);
+                                        half_rounded(size));
                else
                {
                        size >>= 10;
-                       if (size < limit2)
+                       if (Abs(size) < limit2)
                                snprintf(buf, sizeof(buf), INT64_FORMAT " MB",
-                                                (size + 1) / 2);
+                                                half_rounded(size));
                        else
                        {
                                size >>= 10;
-                               if (size < limit2)
+                               if (Abs(size) < limit2)
                                        snprintf(buf, sizeof(buf), INT64_FORMAT " GB",
-                                                        (size + 1) / 2);
+                                                        half_rounded(size));
                                else
                                {
                                        size >>= 10;
                                        snprintf(buf, sizeof(buf), INT64_FORMAT " TB",
-                                                        (size + 1) / 2);
+                                                        half_rounded(size));
                                }
                        }
                }
@@ -593,17 +595,34 @@ numeric_is_less(Numeric a, Numeric b)
 }
 
 static Numeric
-numeric_plus_one_over_two(Numeric n)
+numeric_absolute(Numeric n)
 {
        Datum           d = NumericGetDatum(n);
+       Datum           result;
+
+       result = DirectFunctionCall1(numeric_abs, d);
+       return DatumGetNumeric(result);
+}
+
+static Numeric
+numeric_half_rounded(Numeric n)
+{
+       Datum           d = NumericGetDatum(n);
+       Datum           zero;
        Datum           one;
        Datum           two;
        Datum           result;
 
+       zero = DirectFunctionCall1(int8_numeric, Int64GetDatum(0));
        one = DirectFunctionCall1(int8_numeric, Int64GetDatum(1));
        two = DirectFunctionCall1(int8_numeric, Int64GetDatum(2));
-       result = DirectFunctionCall2(numeric_add, d, one);
-       result = DirectFunctionCall2(numeric_div_trunc, result, two);
+
+       if (DatumGetBool(DirectFunctionCall2(numeric_ge, d, zero)))
+               d = DirectFunctionCall2(numeric_add, d, one);
+       else
+               d = DirectFunctionCall2(numeric_sub, d, one);
+
+       result = DirectFunctionCall2(numeric_div_trunc, d, two);
        return DatumGetNumeric(result);
 }
 
@@ -632,7 +651,7 @@ pg_size_pretty_numeric(PG_FUNCTION_ARGS)
        limit = int64_to_numeric(10 * 1024);
        limit2 = int64_to_numeric(10 * 1024 * 2 - 1);
 
-       if (numeric_is_less(size, limit))
+       if (numeric_is_less(numeric_absolute(size), limit))
        {
                result = psprintf("%s bytes", numeric_to_cstring(size));
        }
@@ -642,20 +661,18 @@ pg_size_pretty_numeric(PG_FUNCTION_ARGS)
                /* size >>= 9 */
                size = numeric_shift_right(size, 9);
 
-               if (numeric_is_less(size, limit2))
+               if (numeric_is_less(numeric_absolute(size), limit2))
                {
-                       /* size = (size + 1) / 2 */
-                       size = numeric_plus_one_over_two(size);
+                       size = numeric_half_rounded(size);
                        result = psprintf("%s kB", numeric_to_cstring(size));
                }
                else
                {
                        /* size >>= 10 */
                        size = numeric_shift_right(size, 10);
-                       if (numeric_is_less(size, limit2))
+                       if (numeric_is_less(numeric_absolute(size), limit2))
                        {
-                               /* size = (size + 1) / 2 */
-                               size = numeric_plus_one_over_two(size);
+                               size = numeric_half_rounded(size);
                                result = psprintf("%s MB", numeric_to_cstring(size));
                        }
                        else
@@ -663,18 +680,16 @@ pg_size_pretty_numeric(PG_FUNCTION_ARGS)
                                /* size >>= 10 */
                                size = numeric_shift_right(size, 10);
 
-                               if (numeric_is_less(size, limit2))
+                               if (numeric_is_less(numeric_absolute(size), limit2))
                                {
-                                       /* size = (size + 1) / 2 */
-                                       size = numeric_plus_one_over_two(size);
+                                       size = numeric_half_rounded(size);
                                        result = psprintf("%s GB", numeric_to_cstring(size));
                                }
                                else
                                {
                                        /* size >>= 10 */
                                        size = numeric_shift_right(size, 10);
-                                       /* size = (size + 1) / 2 */
-                                       size = numeric_plus_one_over_two(size);
+                                       size = numeric_half_rounded(size);
                                        result = psprintf("%s TB", numeric_to_cstring(size));
                                }
                        }

diff --git a/src/test/regress/expected/dbsize.out b/src/test/regress/expected/dbsize.out
new file mode 100644 (file)
index 0000000..aa513e7
--- /dev/null
+++ b/src/test/regress/expected/dbsize.out
@@ -0,0 +1,37 @@
+SELECT size, pg_size_pretty(size), pg_size_pretty(-1 * size) FROM
+    (VALUES (10::bigint), (1000::bigint), (1000000::bigint),
+            (1000000000::bigint), (1000000000000::bigint),
+            (1000000000000000::bigint)) x(size);
+       size       | pg_size_pretty | pg_size_pretty 
+------------------+----------------+----------------
+               10 | 10 bytes       | -10 bytes
+             1000 | 1000 bytes     | -1000 bytes
+          1000000 | 977 kB         | -977 kB
+       1000000000 | 954 MB         | -954 MB
+    1000000000000 | 931 GB         | -931 GB
+ 1000000000000000 | 909 TB         | -909 TB
+(6 rows)
+
+SELECT size, pg_size_pretty(size), pg_size_pretty(-1 * size) FROM
+    (VALUES (10::numeric), (1000::numeric), (1000000::numeric),
+            (1000000000::numeric), (1000000000000::numeric),
+            (1000000000000000::numeric),
+            (10.5::numeric), (1000.5::numeric), (1000000.5::numeric),
+            (1000000000.5::numeric), (1000000000000.5::numeric),
+            (1000000000000000.5::numeric)) x(size);
+        size        | pg_size_pretty | pg_size_pretty 
+--------------------+----------------+----------------
+                 10 | 10 bytes       | -10 bytes
+               1000 | 1000 bytes     | -1000 bytes
+            1000000 | 977 kB         | -977 kB
+         1000000000 | 954 MB         | -954 MB
+      1000000000000 | 931 GB         | -931 GB
+   1000000000000000 | 909 TB         | -909 TB
+               10.5 | 10.5 bytes     | -10.5 bytes
+             1000.5 | 1000.5 bytes   | -1000.5 bytes
+          1000000.5 | 977 kB         | -977 kB
+       1000000000.5 | 954 MB         | -954 MB
+    1000000000000.5 | 931 GB         | -931 GB
+ 1000000000000000.5 | 909 TB         | -909 TB
+(12 rows)
+

diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index c63abf4b0ad57cd5f1a6c7027fc118005b5d4b2e..3987b4c700fd1ca6dd3a2b62e31c69d7efa14a9c 100644 (file)
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -89,7 +89,7 @@ test: brin gin gist spgist privileges security_label collate matview lock replic
 # ----------
 # Another group of parallel tests
 # ----------
-test: alter_generic alter_operator misc psql async
+test: alter_generic alter_operator misc psql async dbsize
 
 # rules cannot run concurrently with any test that creates a view
 test: rules

diff --git a/src/test/regress/serial_schedule b/src/test/regress/serial_schedule
index 88dcd64dfce3b2e82bf07bf813bfc1404538e12b..379f2729be4951c097ddb20d002c13c1b50e6a19 100644 (file)
--- a/src/test/regress/serial_schedule
+++ b/src/test/regress/serial_schedule
@@ -117,6 +117,7 @@ test: alter_operator
 test: misc
 test: psql
 test: async
+test: dbsize
 test: rules
 test: select_views
 test: portals_p2

diff --git a/src/test/regress/sql/dbsize.sql b/src/test/regress/sql/dbsize.sql
new file mode 100644 (file)
index 0000000..c118090
--- /dev/null
+++ b/src/test/regress/sql/dbsize.sql
@@ -0,0 +1,12 @@
+SELECT size, pg_size_pretty(size), pg_size_pretty(-1 * size) FROM
+    (VALUES (10::bigint), (1000::bigint), (1000000::bigint),
+            (1000000000::bigint), (1000000000000::bigint),
+            (1000000000000000::bigint)) x(size);
+
+SELECT size, pg_size_pretty(size), pg_size_pretty(-1 * size) FROM
+    (VALUES (10::numeric), (1000::numeric), (1000000::numeric),
+            (1000000000::numeric), (1000000000000::numeric),
+            (1000000000000000::numeric),
+            (10.5::numeric), (1000.5::numeric), (1000000.5::numeric),
+            (1000000000.5::numeric), (1000000000000.5::numeric),
+            (1000000000000000.5::numeric)) x(size);