Re: [PATCH] expand the units that pg_size_pretty supports on output
| От | David Christensen |
|---|---|
| Тема | Re: [PATCH] expand the units that pg_size_pretty supports on output |
| Дата | |
| Msg-id | lz1r8kwq8f.fsf@veeddrois.attlocal.net обсуждение исходный текст |
| Ответ на | RE: [PATCH] expand the units that pg_size_pretty supports on output (<Shinya11.Kato@nttdata.com>) |
| Ответы |
Re: [PATCH] expand the units that pg_size_pretty supports on output
(David Rowley <dgrowleyml@gmail.com>)
|
| Список | pgsql-hackers |
Shinya11.Kato@nttdata.com writes:
>>I had not really looked at the patch, but if there's a cleanup portion to the same
>>patch as you're adding the YB too, then maybe it's worth separating those out
>>into another patch so that the two can be considered independently.
>
> I agree with this opinion. It seems to me that we should think about units and refactoring separately.
> Sorry for the confusion.
>
> Best regards,
> Shinya Kato
Hi folks,
Had some time to rework this patch from the two that had previously been
here into two separate parts:
1) A basic refactor of the existing code to easily handle expanding the
units we use into a table-based format. This also includes changing the
return value of `pg_size_bytes()` from an int64 into a numeric, and
minor test adjustments to reflect this.
2) Expanding the units that both pg_size_bytes() and pg_size_pretty()
recognize up through Yottabytes. This includes documentation and test
updates to reflect the changes made here. How many additional units we
add here is up for discussion (inevitably), but my opinion remains that
there is no harm in supporting all units available.
Best,
David
From ac30b06e3ddcb57eebb380560c2f4a47430dfd74 Mon Sep 17 00:00:00 2001
From: David Christensen <david.christensen@crunchydata.com>
Date: Tue, 29 Jun 2021 10:20:05 -0500
Subject: [PATCH 1/2] Refactor pg_size_pretty and pg_size_bytes to allow for
supported unit expansion
---
src/backend/utils/adt/dbsize.c | 90 ++++++++++++++++------------
src/include/catalog/pg_proc.dat | 2 +-
src/test/regress/expected/dbsize.out | 4 --
src/test/regress/sql/dbsize.sql | 2 -
4 files changed, 53 insertions(+), 45 deletions(-)
diff --git a/src/backend/utils/adt/dbsize.c b/src/backend/utils/adt/dbsize.c
index 9c39e7d3b3..df08845932 100644
--- a/src/backend/utils/adt/dbsize.c
+++ b/src/backend/utils/adt/dbsize.c
@@ -638,7 +638,7 @@ pg_size_pretty_numeric(PG_FUNCTION_ARGS)
Numeric size = PG_GETARG_NUMERIC(0);
Numeric limit,
limit2;
- char *result;
+ char *result = NULL;
limit = int64_to_numeric(10 * 1024);
limit2 = int64_to_numeric(10 * 1024 * 2 - 1);
@@ -660,31 +660,32 @@ pg_size_pretty_numeric(PG_FUNCTION_ARGS)
}
else
{
- /* size >>= 10 */
- size = numeric_shift_right(size, 10);
- if (numeric_is_less(numeric_absolute(size), limit2))
- {
- size = numeric_half_rounded(size);
- result = psprintf("%s MB", numeric_to_cstring(size));
- }
- else
- {
+ int idx, max_iter = 2; /* highest index of table_below */
+ char *output_formats[] = {
+ "%s MB",
+ "%s GB",
+ "%s TB"
+ };
+
+ for (idx = 0; idx < max_iter; idx++) {
/* size >>= 10 */
size = numeric_shift_right(size, 10);
-
if (numeric_is_less(numeric_absolute(size), limit2))
{
size = numeric_half_rounded(size);
- result = psprintf("%s GB", numeric_to_cstring(size));
- }
- else
- {
- /* size >>= 10 */
- size = numeric_shift_right(size, 10);
- size = numeric_half_rounded(size);
- result = psprintf("%s TB", numeric_to_cstring(size));
+ result = psprintf(output_formats[idx], numeric_to_cstring(size));
+ break;
}
}
+
+ if (!result) {
+ /* this uses the last format in the table above for anything else */
+
+ /* size >>= 10 */
+ size = numeric_shift_right(size, 10);
+ size = numeric_half_rounded(size);
+ result = psprintf(output_formats[max_iter], numeric_to_cstring(size));
+ }
}
}
@@ -703,7 +704,6 @@ pg_size_bytes(PG_FUNCTION_ARGS)
*endptr;
char saved_char;
Numeric num;
- int64 result;
bool have_digits = false;
str = text_to_cstring(arg);
@@ -786,7 +786,16 @@ pg_size_bytes(PG_FUNCTION_ARGS)
/* Handle possible unit */
if (*strptr != '\0')
{
- int64 multiplier = 0;
+ int64 multiplier = 1;
+ int i;
+ int unit_count = 5; /* sizeof units table */
+ char *units[] = {
+ "bytes",
+ "kb",
+ "mb",
+ "gb",
+ "tb",
+ };
/* Trim any trailing whitespace */
endptr = str + VARSIZE_ANY_EXHDR(arg) - 1;
@@ -797,21 +806,20 @@ pg_size_bytes(PG_FUNCTION_ARGS)
endptr++;
*endptr = '\0';
- /* Parse the unit case-insensitively */
- if (pg_strcasecmp(strptr, "bytes") == 0)
- multiplier = (int64) 1;
- else if (pg_strcasecmp(strptr, "kb") == 0)
- multiplier = (int64) 1024;
- else if (pg_strcasecmp(strptr, "mb") == 0)
- multiplier = ((int64) 1024) * 1024;
-
- else if (pg_strcasecmp(strptr, "gb") == 0)
- multiplier = ((int64) 1024) * 1024 * 1024;
-
- else if (pg_strcasecmp(strptr, "tb") == 0)
- multiplier = ((int64) 1024) * 1024 * 1024 * 1024;
+ for (i = 0; i < unit_count; i++) {
+ printf("strptr: %s units: %s", strptr, units[i]);
+ if (pg_strcasecmp(strptr, units[i]) == 0)
+ break;
+ /*
+ * Note: int64 isn't large enough to store the full multiplier
+ * going past ~ 9EB, but since this is a fixed value, we can apply
+ * it twice, thus storing use 2 ** 5 = 32 here, but 2 ** 10 = 1024
+ * on actual conversion to numeric.
+ */
+ multiplier *= 32;
+ }
- else
+ if (i == unit_count)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("invalid size: \"%s\"", text_to_cstring(arg)),
@@ -827,13 +835,19 @@ pg_size_bytes(PG_FUNCTION_ARGS)
num = DatumGetNumeric(DirectFunctionCall2(numeric_mul,
NumericGetDatum(mul_num),
NumericGetDatum(num)));
+
+ /* second application to get around int64 limitations in unit multipliers */
+ num = DatumGetNumeric(DirectFunctionCall2(numeric_mul,
+ NumericGetDatum(mul_num),
+ NumericGetDatum(num)));
}
}
- result = DatumGetInt64(DirectFunctionCall1(numeric_int8,
- NumericGetDatum(num)));
+ /* now finally truncate, since this is always in integer-like units */
+ num = DatumGetNumeric(DirectFunctionCall1(numeric_ceil,
+ NumericGetDatum(num)));
- PG_RETURN_INT64(result);
+ PG_RETURN_NUMERIC(num);
}
/*
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index fde251fa4f..73326e3618 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -7187,7 +7187,7 @@
prosrc => 'pg_size_pretty_numeric' },
{ oid => '3334',
descr => 'convert a size in human-readable format with size units into bytes',
- proname => 'pg_size_bytes', prorettype => 'int8', proargtypes => 'text',
+ proname => 'pg_size_bytes', prorettype => 'numeric', proargtypes => 'text',
prosrc => 'pg_size_bytes' },
{ oid => '2997',
descr => 'disk space usage for the specified table, including TOAST, free space and visibility map',
diff --git a/src/test/regress/expected/dbsize.out b/src/test/regress/expected/dbsize.out
index e901a2c92a..624948ccd2 100644
--- a/src/test/regress/expected/dbsize.out
+++ b/src/test/regress/expected/dbsize.out
@@ -114,10 +114,6 @@ SELECT pg_size_bytes('1 AB A ');
ERROR: invalid size: "1 AB A "
DETAIL: Invalid size unit: "AB A".
HINT: Valid units are "bytes", "kB", "MB", "GB", and "TB".
-SELECT pg_size_bytes('9223372036854775807.9');
-ERROR: bigint out of range
-SELECT pg_size_bytes('1e100');
-ERROR: bigint out of range
SELECT pg_size_bytes('1e1000000000000000000');
ERROR: value overflows numeric format
SELECT pg_size_bytes('1 byte'); -- the singular "byte" is not supported
diff --git a/src/test/regress/sql/dbsize.sql b/src/test/regress/sql/dbsize.sql
index d10a4d7f68..37023a01c3 100644
--- a/src/test/regress/sql/dbsize.sql
+++ b/src/test/regress/sql/dbsize.sql
@@ -34,8 +34,6 @@ SELECT size, pg_size_bytes(size) FROM
SELECT pg_size_bytes('1 AB');
SELECT pg_size_bytes('1 AB A');
SELECT pg_size_bytes('1 AB A ');
-SELECT pg_size_bytes('9223372036854775807.9');
-SELECT pg_size_bytes('1e100');
SELECT pg_size_bytes('1e1000000000000000000');
SELECT pg_size_bytes('1 byte'); -- the singular "byte" is not supported
SELECT pg_size_bytes('');
--
2.30.1 (Apple Git-130)
From e3fc63d9be6af5725a0ed24e16513cb711631f4a Mon Sep 17 00:00:00 2001
From: David Christensen <david.christensen@crunchydata.com>
Date: Tue, 29 Jun 2021 10:02:50 -0500
Subject: [PATCH 2/2] Full expansion of all units
---
doc/src/sgml/func.sgml | 2 +-
src/backend/utils/adt/dbsize.c | 22 +++-
src/test/regress/expected/dbsize.out | 180 +++++++++++++++++----------
src/test/regress/sql/dbsize.sql | 39 ++++--
4 files changed, 164 insertions(+), 79 deletions(-)
diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 6388385edc..687d2a7ac8 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -26354,7 +26354,7 @@ postgres=# SELECT * FROM pg_walfile_name_offset(pg_stop_backup());
</para>
<para>
Converts a size in bytes into a more easily human-readable format with
- size units (bytes, kB, MB, GB or TB as appropriate). Note that the
+ size units (bytes, kB, MB, GB, TB, PB, EB, ZB, or YB as appropriate). Note that the
units are powers of 2 rather than powers of 10, so 1kB is 1024 bytes,
1MB is 1024<superscript>2</superscript> = 1048576 bytes, and so on.
</para></entry>
diff --git a/src/backend/utils/adt/dbsize.c b/src/backend/utils/adt/dbsize.c
index df08845932..5650bb9f2b 100644
--- a/src/backend/utils/adt/dbsize.c
+++ b/src/backend/utils/adt/dbsize.c
@@ -660,11 +660,15 @@ pg_size_pretty_numeric(PG_FUNCTION_ARGS)
}
else
{
- int idx, max_iter = 2; /* highest index of table_below */
+ int idx, max_iter = 6; /* highest index of table_below */
char *output_formats[] = {
"%s MB",
"%s GB",
- "%s TB"
+ "%s TB",
+ "%s PB",
+ "%s EB",
+ "%s ZB",
+ "%s YB"
};
for (idx = 0; idx < max_iter; idx++) {
@@ -755,8 +759,9 @@ pg_size_bytes(PG_FUNCTION_ARGS)
char *cp;
/*
- * Note we might one day support EB units, so if what follows 'E'
- * isn't a number, just treat it all as a unit to be parsed.
+ * If what follows 'e' isn't a number, we just treat it all as a unit
+ * to be parsed; this allows us to support both exponential notation
+ * and EB units.
*/
exponent = strtol(endptr + 1, &cp, 10);
(void) exponent; /* Silence -Wunused-result warnings */
@@ -788,13 +793,17 @@ pg_size_bytes(PG_FUNCTION_ARGS)
{
int64 multiplier = 1;
int i;
- int unit_count = 5; /* sizeof units table */
+ int unit_count = 9; /* sizeof units table */
char *units[] = {
"bytes",
"kb",
"mb",
"gb",
"tb",
+ "pb",
+ "eb",
+ "zb",
+ "yb",
};
/* Trim any trailing whitespace */
@@ -824,7 +833,8 @@ pg_size_bytes(PG_FUNCTION_ARGS)
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("invalid size: \"%s\"", text_to_cstring(arg)),
errdetail("Invalid size unit: \"%s\".", strptr),
- errhint("Valid units are \"bytes\", \"kB\", \"MB\", \"GB\", and \"TB\".")));
+ errhint("Valid units are \"bytes\", \"kB\", \"MB\", \"GB\", \"TB\", "
+ "\"PB\", \"EB\", \"ZB\", and \"YB\".")));
if (multiplier > 1)
{
diff --git a/src/test/regress/expected/dbsize.out b/src/test/regress/expected/dbsize.out
index 624948ccd2..8993522904 100644
--- a/src/test/regress/expected/dbsize.out
+++ b/src/test/regress/expected/dbsize.out
@@ -13,77 +13,116 @@ SELECT size, pg_size_pretty(size), pg_size_pretty(-1 * size) FROM
(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),
+ (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)
+ (1000000000000000000::numeric),
+ (1000000000000000000000::numeric),
+ (1000000000000000000000000::numeric),
+ (1000000000000000000000000000::numeric),
+ (1000000000000000000000000000000::numeric),
+ (10.5::numeric),
+ (1000.5::numeric),
+ (1000000.5::numeric),
+ (1000000000.5::numeric),
+ (1000000000000.5::numeric),
+ (1000000000000000.5::numeric),
+ (1000000000000000000.5::numeric),
+ (1000000000000000000000.5::numeric),
+ (1000000000000000000000000.5::numeric),
+ (1000000000000000000000000000.5::numeric),
+ (1000000000000000000000000000000.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
+ 1000000000000000000 | 888 PB | -888 PB
+ 1000000000000000000000 | 867 EB | -867 EB
+ 1000000000000000000000000 | 847 ZB | -847 ZB
+ 1000000000000000000000000000 | 827 YB | -827 YB
+ 1000000000000000000000000000000 | 827181 YB | -827181 YB
+ 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
+ 1000000000000000000.5 | 888 PB | -888 PB
+ 1000000000000000000000.5 | 867 EB | -867 EB
+ 1000000000000000000000000.5 | 847 ZB | -847 ZB
+ 1000000000000000000000000000.5 | 827 YB | -827 YB
+ 1000000000000000000000000000000.5 | 827181 YB | -827181 YB
+(22 rows)
SELECT size, pg_size_bytes(size) FROM
(VALUES ('1'), ('123bytes'), ('1kB'), ('1MB'), (' 1 GB'), ('1.5 GB '),
- ('1TB'), ('3000 TB'), ('1e6 MB')) x(size);
- size | pg_size_bytes
-----------+------------------
- 1 | 1
- 123bytes | 123
- 1kB | 1024
- 1MB | 1048576
- 1 GB | 1073741824
- 1.5 GB | 1610612736
- 1TB | 1099511627776
- 3000 TB | 3298534883328000
- 1e6 MB | 1048576000000
-(9 rows)
+ ('1TB'), ('3000 TB'), ('1e6 MB'), ('99 PB'), ('45 EB'), ('5.1ZB'),
+ ('1.17 YB')) x(size);
+ size | pg_size_bytes
+----------+---------------------------
+ 1 | 1
+ 123bytes | 123
+ 1kB | 1024
+ 1MB | 1048576
+ 1 GB | 1073741824
+ 1.5 GB | 1610612736
+ 1TB | 1099511627776
+ 3000 TB | 3298534883328000
+ 1e6 MB | 1048576000000
+ 99 PB | 111464090777419776
+ 45 EB | 51881467707308113920
+ 5.1ZB | 6021017265658797647463
+ 1.17 YB | 1414443208949116134406226
+(13 rows)
-- case-insensitive units are supported
SELECT size, pg_size_bytes(size) FROM
(VALUES ('1'), ('123bYteS'), ('1kb'), ('1mb'), (' 1 Gb'), ('1.5 gB '),
- ('1tb'), ('3000 tb'), ('1e6 mb')) x(size);
- size | pg_size_bytes
-----------+------------------
- 1 | 1
- 123bYteS | 123
- 1kb | 1024
- 1mb | 1048576
- 1 Gb | 1073741824
- 1.5 gB | 1610612736
- 1tb | 1099511627776
- 3000 tb | 3298534883328000
- 1e6 mb | 1048576000000
-(9 rows)
+ ('1tb'), ('3000 tb'), ('1e6 mb'), ('99 pb'), ('45 eB'), ('5.1Zb'),
+ ('1.17 yb')) x(size);
+ size | pg_size_bytes
+----------+---------------------------
+ 1 | 1
+ 123bYteS | 123
+ 1kb | 1024
+ 1mb | 1048576
+ 1 Gb | 1073741824
+ 1.5 gB | 1610612736
+ 1tb | 1099511627776
+ 3000 tb | 3298534883328000
+ 1e6 mb | 1048576000000
+ 99 pb | 111464090777419776
+ 45 eB | 51881467707308113920
+ 5.1Zb | 6021017265658797647463
+ 1.17 yb | 1414443208949116134406226
+(13 rows)
-- negative numbers are supported
SELECT size, pg_size_bytes(size) FROM
(VALUES ('-1'), ('-123bytes'), ('-1kb'), ('-1mb'), (' -1 Gb'), ('-1.5 gB '),
- ('-1tb'), ('-3000 TB'), ('-10e-1 MB')) x(size);
- size | pg_size_bytes
------------+-------------------
- -1 | -1
- -123bytes | -123
- -1kb | -1024
- -1mb | -1048576
- -1 Gb | -1073741824
- -1.5 gB | -1610612736
- -1tb | -1099511627776
- -3000 TB | -3298534883328000
- -10e-1 MB | -1048576
-(9 rows)
+ ('-1tb'), ('-3000 TB'), ('-10e-1 MB'), ('-19e-4eb'), ('-18YB')) x(size);
+ size | pg_size_bytes
+-----------+-----------------------------
+ -1 | -1
+ -123bytes | -123
+ -1kb | -1024
+ -1mb | -1048576
+ -1 Gb | -1073741824
+ -1.5 gB | -1610612736
+ -1tb | -1099511627776
+ -3000 TB | -3298534883328000
+ -10e-1 MB | -1048576
+ -19e-4eb | -2190550858753009
+ -18YB | -21760664753063325144711168
+(11 rows)
-- different cases with allowed points
SELECT size, pg_size_bytes(size) FROM
@@ -101,25 +140,38 @@ SELECT size, pg_size_bytes(size) FROM
-.0 gb | 0
(8 rows)
+-- valid inputs outside bigint range (previous errors)
+SELECT pg_size_bytes('9223372036854775807.9');
+ pg_size_bytes
+---------------------
+ 9223372036854775808
+(1 row)
+
+SELECT pg_size_bytes('1e100');
+ pg_size_bytes
+-------------------------------------------------------------------------------------------------------
+ 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+(1 row)
+
-- invalid inputs
SELECT pg_size_bytes('1 AB');
ERROR: invalid size: "1 AB"
DETAIL: Invalid size unit: "AB".
-HINT: Valid units are "bytes", "kB", "MB", "GB", and "TB".
+HINT: Valid units are "bytes", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", and "YB".
SELECT pg_size_bytes('1 AB A');
ERROR: invalid size: "1 AB A"
DETAIL: Invalid size unit: "AB A".
-HINT: Valid units are "bytes", "kB", "MB", "GB", and "TB".
+HINT: Valid units are "bytes", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", and "YB".
SELECT pg_size_bytes('1 AB A ');
ERROR: invalid size: "1 AB A "
DETAIL: Invalid size unit: "AB A".
-HINT: Valid units are "bytes", "kB", "MB", "GB", and "TB".
+HINT: Valid units are "bytes", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", and "YB".
SELECT pg_size_bytes('1e1000000000000000000');
ERROR: value overflows numeric format
SELECT pg_size_bytes('1 byte'); -- the singular "byte" is not supported
ERROR: invalid size: "1 byte"
DETAIL: Invalid size unit: "byte".
-HINT: Valid units are "bytes", "kB", "MB", "GB", and "TB".
+HINT: Valid units are "bytes", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", and "YB".
SELECT pg_size_bytes('');
ERROR: invalid size: ""
SELECT pg_size_bytes('kb');
@@ -137,6 +189,6 @@ ERROR: invalid size: ".+912"
SELECT pg_size_bytes('+912+ kB');
ERROR: invalid size: "+912+ kB"
DETAIL: Invalid size unit: "+ kB".
-HINT: Valid units are "bytes", "kB", "MB", "GB", and "TB".
+HINT: Valid units are "bytes", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", and "YB".
SELECT pg_size_bytes('++123 kB');
ERROR: invalid size: "++123 kB"
diff --git a/src/test/regress/sql/dbsize.sql b/src/test/regress/sql/dbsize.sql
index 37023a01c3..2a4abcfc65 100644
--- a/src/test/regress/sql/dbsize.sql
+++ b/src/test/regress/sql/dbsize.sql
@@ -4,32 +4,55 @@ SELECT size, pg_size_pretty(size), pg_size_pretty(-1 * size) FROM
(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),
+ (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);
+ (1000000000000000000::numeric),
+ (1000000000000000000000::numeric),
+ (1000000000000000000000000::numeric),
+ (1000000000000000000000000000::numeric),
+ (1000000000000000000000000000000::numeric),
+ (10.5::numeric),
+ (1000.5::numeric),
+ (1000000.5::numeric),
+ (1000000000.5::numeric),
+ (1000000000000.5::numeric),
+ (1000000000000000.5::numeric),
+ (1000000000000000000.5::numeric),
+ (1000000000000000000000.5::numeric),
+ (1000000000000000000000000.5::numeric),
+ (1000000000000000000000000000.5::numeric),
+ (1000000000000000000000000000000.5::numeric)
+ ) x(size);
SELECT size, pg_size_bytes(size) FROM
(VALUES ('1'), ('123bytes'), ('1kB'), ('1MB'), (' 1 GB'), ('1.5 GB '),
- ('1TB'), ('3000 TB'), ('1e6 MB')) x(size);
+ ('1TB'), ('3000 TB'), ('1e6 MB'), ('99 PB'), ('45 EB'), ('5.1ZB'),
+ ('1.17 YB')) x(size);
-- case-insensitive units are supported
SELECT size, pg_size_bytes(size) FROM
(VALUES ('1'), ('123bYteS'), ('1kb'), ('1mb'), (' 1 Gb'), ('1.5 gB '),
- ('1tb'), ('3000 tb'), ('1e6 mb')) x(size);
+ ('1tb'), ('3000 tb'), ('1e6 mb'), ('99 pb'), ('45 eB'), ('5.1Zb'),
+ ('1.17 yb')) x(size);
-- negative numbers are supported
SELECT size, pg_size_bytes(size) FROM
(VALUES ('-1'), ('-123bytes'), ('-1kb'), ('-1mb'), (' -1 Gb'), ('-1.5 gB '),
- ('-1tb'), ('-3000 TB'), ('-10e-1 MB')) x(size);
+ ('-1tb'), ('-3000 TB'), ('-10e-1 MB'), ('-19e-4eb'), ('-18YB')) x(size);
-- different cases with allowed points
SELECT size, pg_size_bytes(size) FROM
(VALUES ('-1.'), ('-1.kb'), ('-1. kb'), ('-0. gb'),
('-.1'), ('-.1kb'), ('-.1 kb'), ('-.0 gb')) x(size);
+-- valid inputs outside bigint range (previous errors)
+SELECT pg_size_bytes('9223372036854775807.9');
+SELECT pg_size_bytes('1e100');
+
-- invalid inputs
SELECT pg_size_bytes('1 AB');
SELECT pg_size_bytes('1 AB A');
--
2.30.1 (Apple Git-130)
В списке pgsql-hackers по дате отправления: