mirror/postgresql
2
0
Fork 0
mirror of https://git.postgresql.org/git/postgresql.git synced 2025-03-19 20:00:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Rework pg_input_error_message(), now renamed pg_input_error_info()

Browse Source 
pg_input_error_info() is now a SQL function able to return a row with
more than just the error message generated for incorrect data type
inputs when these are able to handle soft failures, returning more
contents of ErrorData, as of:
- The error message (same as before).
- The error detail, if set.
- The error hint, if set.
- SQL error code.

All the regression tests that relied on pg_input_error_message() are
updated to reflect the effects of the rename.

Per discussion with Tom Lane and Andrew Dunstan.

Author: Nathan Bossart
Discussion: https://postgr.es/m/139a68e1-bd1f-a9a7-b5fe-0be9845c6311@dunslane.net
This commit is contained in:
Michael Paquier 2023-02-28 08:04:13 +09:00
parent 728560db7d
commit b8da37b3ad
117 changed files with 768 additions and 682 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
contrib/cube/expected/cube.out
View File

@ -344,10 +344,10 @@ SELECT pg_input_is_valid('-1e-700', 'cube');
f
(1 row)
SELECT pg_input_error_message('-1e-700', 'cube');
pg_input_error_message
-----------------------------------------------------
"-1e-700" is out of range for type double precision
SELECT * FROM pg_input_error_info('-1e-700', 'cube');
message | detail | hint | sql_error_code
-----------------------------------------------------+--------+------+----------------
"-1e-700" is out of range for type double precision | | | 22003
(1 row)
--

2
contrib/cube/sql/cube.sql
View File

@ -83,7 +83,7 @@ SELECT '-1e-700'::cube AS cube; -- out of range
SELECT pg_input_is_valid('(1,2)', 'cube');
SELECT pg_input_is_valid('[(1),]', 'cube');
SELECT pg_input_is_valid('-1e-700', 'cube');
SELECT pg_input_error_message('-1e-700', 'cube');
SELECT * FROM pg_input_error_info('-1e-700', 'cube');
--
-- Testing building cubes from float8 values

16
contrib/hstore/expected/hstore.out
View File

@ -265,16 +265,16 @@ select pg_input_is_valid('a=b', 'hstore');
f
(1 row)
select pg_input_error_message('a=b', 'hstore');
pg_input_error_message
------------------------------------------------
syntax error in hstore, near "b" at position 2
select * from pg_input_error_info('a=b', 'hstore');
message | detail | hint | sql_error_code
------------------------------------------------+--------+------+----------------
syntax error in hstore, near "b" at position 2 | | | 42601
(1 row)
select pg_input_error_message(' =>b', 'hstore');
pg_input_error_message
------------------------------------------------
syntax error in hstore, near "=" at position 1
select * from pg_input_error_info(' =>b', 'hstore');
message | detail | hint | sql_error_code
------------------------------------------------+--------+------+----------------
syntax error in hstore, near "=" at position 1 | | | 42601
(1 row)
-- -> operator

4
contrib/hstore/sql/hstore.sql
View File

@ -60,8 +60,8 @@ select 'aa=>"'::hstore;
-- also try it with non-error-throwing API
select pg_input_is_valid('a=>b', 'hstore');
select pg_input_is_valid('a=b', 'hstore');
select pg_input_error_message('a=b', 'hstore');
select pg_input_error_message(' =>b', 'hstore');
select * from pg_input_error_info('a=b', 'hstore');
select * from pg_input_error_info(' =>b', 'hstore');
-- -> operator

18
contrib/intarray/expected/_int.out
View File

@ -401,16 +401,20 @@ SELECT '1&(2&(4&(5|!6)))'::query_int;
-- test non-error-throwing input
SELECT str as "query_int",
pg_input_is_valid(str,'query_int') as ok,
pg_input_error_message(str,'query_int') as errmsg
errinfo.sql_error_code,
errinfo.message,
errinfo.detail,
errinfo.hint
FROM (VALUES ('1&(2&(4&(5|6)))'),
('1#(2&(4&(5&6)))'),
('foo'))
AS a(str);
query_int | ok | errmsg
-----------------+----+--------------
1&(2&(4&(5|6))) | t |
1#(2&(4&(5&6))) | f | syntax error
foo | f | syntax error
AS a(str),
LATERAL pg_input_error_info(a.str, 'query_int') as errinfo;
query_int | ok | sql_error_code | message | detail | hint
-----------------+----+----------------+--------------+--------+------
1&(2&(4&(5|6))) | t | | | |
1#(2&(4&(5&6))) | f | 42601 | syntax error | |
foo | f | 42601 | syntax error | |
(3 rows)
CREATE TABLE test__int( a int[] );

8
contrib/intarray/sql/_int.sql
View File

@ -79,11 +79,15 @@ SELECT '1&(2&(4&(5|!6)))'::query_int;
SELECT str as "query_int",
pg_input_is_valid(str,'query_int') as ok,
pg_input_error_message(str,'query_int') as errmsg
errinfo.sql_error_code,
errinfo.message,
errinfo.detail,
errinfo.hint
FROM (VALUES ('1&(2&(4&(5|6)))'),
('1#(2&(4&(5&6)))'),
('foo'))
AS a(str);
AS a(str),
LATERAL pg_input_error_info(a.str, 'query_int') as errinfo;

18
contrib/isn/expected/isn.out
View File

@ -263,16 +263,20 @@ SELECT '12345679'::ISSN = '9771234567003'::EAN13 AS "ok",
-- test non-error-throwing input API
SELECT str as isn, typ as "type",
pg_input_is_valid(str,typ) as ok,
pg_input_error_message(str,typ) as errmsg
errinfo.sql_error_code,
errinfo.message,
errinfo.detail,
errinfo.hint
FROM (VALUES ('9780123456786', 'UPC'),
('postgresql...','EAN13'),
('9771234567003','ISSN'))
AS a(str,typ);
isn | type | ok | errmsg
---------------+-------+----+--------------------------------------------------------
9780123456786 | UPC | f | cannot cast ISBN to UPC for number: "9780123456786"
postgresql... | EAN13 | f | invalid input syntax for EAN13 number: "postgresql..."
9771234567003 | ISSN | t |
AS a(str,typ),
LATERAL pg_input_error_info(a.str, a.typ) as errinfo;
isn | type | ok | sql_error_code | message | detail | hint
---------------+-------+----+----------------+--------------------------------------------------------+--------+------
9780123456786 | UPC | f | 22P02 | cannot cast ISBN to UPC for number: "9780123456786" | |
postgresql... | EAN13 | f | 22P02 | invalid input syntax for EAN13 number: "postgresql..." | |
9771234567003 | ISSN | t | | | |
(3 rows)
--

8
contrib/isn/sql/isn.sql
View File

@ -110,11 +110,15 @@ SELECT '12345679'::ISSN = '9771234567003'::EAN13 AS "ok",
-- test non-error-throwing input API
SELECT str as isn, typ as "type",
pg_input_is_valid(str,typ) as ok,
pg_input_error_message(str,typ) as errmsg
errinfo.sql_error_code,
errinfo.message,
errinfo.detail,
errinfo.hint
FROM (VALUES ('9780123456786', 'UPC'),
('postgresql...','EAN13'),
('9771234567003','ISSN'))
AS a(str,typ);
AS a(str,typ),
LATERAL pg_input_error_info(a.str, a.typ) as errinfo;
--
-- cleanup

28
contrib/ltree/expected/ltree.out
View File

@ -8101,7 +8101,10 @@ SELECT count(*) FROM _ltreetest WHERE t ? '{23.*.1,23.*.2}' ;
-- test non-error-throwing input
SELECT str as "value", typ as "type",
pg_input_is_valid(str,typ) as ok,
pg_input_error_message(str,typ) as errmsg
errinfo.sql_error_code,
errinfo.message,
errinfo.detail,
errinfo.hint
FROM (VALUES ('.2.3', 'ltree'),
('1.2.', 'ltree'),
('1.2.3','ltree'),
@ -8110,16 +8113,17 @@ FROM (VALUES ('.2.3', 'ltree'),
('1.2.3','lquery'),
('$tree & aWdf@*','ltxtquery'),
('!tree & aWdf@*','ltxtquery'))
AS a(str,typ);
value | type | ok | errmsg
----------------+-----------+----+------------------------------------
.2.3 | ltree | f | ltree syntax error at character 1
1.2. | ltree | f | ltree syntax error
1.2.3 | ltree | t |
@.2.3 | lquery | f | lquery syntax error at character 1
2.3 | lquery | f | lquery syntax error at character 1
1.2.3 | lquery | t |
$tree & aWdf@* | ltxtquery | f | operand syntax error
!tree & aWdf@* | ltxtquery | t |
AS a(str,typ),
LATERAL pg_input_error_info(a.str, a.typ) as errinfo;
value | type | ok | sql_error_code | message | detail | hint
----------------+-----------+----+----------------+------------------------------------+--------------------------+------
.2.3 | ltree | f | 42601 | ltree syntax error at character 1 | |
1.2. | ltree | f | 42601 | ltree syntax error | Unexpected end of input. |
1.2.3 | ltree | t | | | |
@.2.3 | lquery | f | 42601 | lquery syntax error at character 1 | |
2.3 | lquery | f | 42601 | lquery syntax error at character 1 | |
1.2.3 | lquery | t | | | |
$tree & aWdf@* | ltxtquery | f | 42601 | operand syntax error | |
!tree & aWdf@* | ltxtquery | t | | | |
(8 rows)

8
contrib/ltree/sql/ltree.sql
View File

@ -393,7 +393,10 @@ SELECT count(*) FROM _ltreetest WHERE t ? '{23.*.1,23.*.2}' ;
SELECT str as "value", typ as "type",
pg_input_is_valid(str,typ) as ok,
pg_input_error_message(str,typ) as errmsg
errinfo.sql_error_code,
errinfo.message,
errinfo.detail,
errinfo.hint
FROM (VALUES ('.2.3', 'ltree'),
('1.2.', 'ltree'),
('1.2.3','ltree'),
@ -402,4 +405,5 @@ FROM (VALUES ('.2.3', 'ltree'),
('1.2.3','lquery'),
('$tree & aWdf@*','ltxtquery'),
('!tree & aWdf@*','ltxtquery'))
AS a(str,typ);
AS a(str,typ),
LATERAL pg_input_error_info(a.str, a.typ) as errinfo;

24
contrib/seg/expected/seg.out
View File

@ -1276,20 +1276,24 @@ FROM test_seg WHERE s @> '11.2..11.3' OR s IS NULL ORDER BY s;
-- test non error throwing API
SELECT str as seg,
pg_input_is_valid(str,'seg') as ok,
pg_input_error_message(str,'seg') as errmsg
errinfo.sql_error_code,
errinfo.message,
errinfo.detail,
errinfo.hint
FROM unnest(ARRAY['-1 .. 1'::text,
'100(+-)1',
'',
'ABC',
'1 e7',
'1e700']) str;
seg | ok | errmsg
----------+----+---------------------------------------
-1 .. 1 | t |
100(+-)1 | t |
| f | bad seg representation
ABC | f | bad seg representation
1 e7 | f | bad seg representation
1e700 | f | "1e700" is out of range for type real
'1e700']) str,
LATERAL pg_input_error_info(str, 'seg') as errinfo;
seg | ok | sql_error_code | message | detail | hint
----------+----+----------------+---------------------------------------+------------------------------+------
-1 .. 1 | t | | | |
100(+-)1 | t | | | |
| f | 42601 | bad seg representation | syntax error at end of input |
ABC | f | 42601 | bad seg representation | syntax error at or near "A" |
1 e7 | f | 42601 | bad seg representation | syntax error at or near "e" |
1e700 | f | 22003 | "1e700" is out of range for type real | |
(6 rows)

8
contrib/seg/sql/seg.sql
View File

@ -244,10 +244,14 @@ FROM test_seg WHERE s @> '11.2..11.3' OR s IS NULL ORDER BY s;
SELECT str as seg,
pg_input_is_valid(str,'seg') as ok,
pg_input_error_message(str,'seg') as errmsg
errinfo.sql_error_code,
errinfo.message,
errinfo.detail,
errinfo.hint
FROM unnest(ARRAY['-1 .. 1'::text,
'100(+-)1',
'',
'ABC',
'1 e7',
'1e700']) str;
'1e700']) str,
LATERAL pg_input_error_info(str, 'seg') as errinfo;

33
doc/src/sgml/func.sgml
View File

@ -24775,19 +24775,23 @@ SELECT collation for ('foo' COLLATE "de_DE");
<row>
<entry role="func_table_entry"><para role="func_signature">
<indexterm>
<primary>pg_input_error_message</primary>
<primary>pg_input_error_info</primary>
</indexterm>
<function>pg_input_error_message</function> (
<function>pg_input_error_info</function> (
<parameter>string</parameter> <type>text</type>,
<parameter>type</parameter> <type>text</type>
)
<returnvalue>text</returnvalue>
<returnvalue>record</returnvalue>
( <parameter>message</parameter> <type>text</type>,
<parameter>detail</parameter> <type>text</type>,
<parameter>hint</parameter> <type>text</type>,
<parameter>sql_error_code</parameter> <type>text</type> )
</para>
<para>
Tests whether the given <parameter>string</parameter> is valid
input for the specified data type; if not, return the error
message that would have been thrown. If the input is valid, the
result is NULL. The inputs are the same as
input for the specified data type; if not, return the details of
the error would have been thrown. If the input is valid, the
results are NULL. The inputs are the same as
for <function>pg_input_is_valid</function>.
</para>
<para>
@ -24798,12 +24802,17 @@ SELECT collation for ('foo' COLLATE "de_DE");
directly.
</para>
<para>
<literal>pg_input_error_message('42000000000', 'integer')</literal>
<returnvalue>value "42000000000" is out of range for type integer</returnvalue>
</para>
<para>
<literal>pg_input_error_message('1234.567', 'numeric(7,4)')</literal>
<returnvalue>numeric field overflow</returnvalue>
<programlisting>
SELECT * FROM pg_input_error_info('42000000000', 'integer');
message | detail | hint | sql_error_code
------------------------------------------------------+--------+------+----------------
value "42000000000" is out of range for type integer | | | 22003
SELECT * FROM pg_input_error_info('1234.567', 'numeric(7,4)');
message | detail | hint | sql_error_code
------------------------+-----------------------------------------------------------------------------------+------+----------------
numeric field overflow | A field with precision 7, scale 4 must round to an absolute value less than 10^3. | | 22003
</programlisting>
</para></entry>
</row>
</tbody>

44
src/backend/utils/adt/misc.c
View File

@ -660,32 +660,60 @@ pg_input_is_valid(PG_FUNCTION_ARGS)
}
/*
* pg_input_error_message - test whether string is valid input for datatype.
* pg_input_error_info - test whether string is valid input for datatype.
*
* Returns NULL if OK, else the primary message string from the error.
* Returns NULL if OK, else the primary message, detail message, hint message
* and sql error code from the error.
*
* This will only work usefully if the datatype's input function has been
* updated to return "soft" errors via errsave/ereturn.
*/
Datum
pg_input_error_message(PG_FUNCTION_ARGS)
pg_input_error_info(PG_FUNCTION_ARGS)
{
text *txt = PG_GETARG_TEXT_PP(0);
text *typname = PG_GETARG_TEXT_PP(1);
ErrorSaveContext escontext = {T_ErrorSaveContext};
TupleDesc tupdesc;
Datum values[4];
bool isnull[4];
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
elog(ERROR, "return type must be a row type");
/* Enable details_wanted */
escontext.details_wanted = true;
if (pg_input_is_valid_common(fcinfo, txt, typname,
&escontext))
PG_RETURN_NULL();
memset(isnull, true, sizeof(isnull));
else
{
char *sqlstate;
Assert(escontext.error_occurred);
Assert(escontext.error_data != NULL);
Assert(escontext.error_data->message != NULL);
Assert(escontext.error_occurred);
Assert(escontext.error_data != NULL);
Assert(escontext.error_data->message != NULL);
PG_RETURN_TEXT_P(cstring_to_text(escontext.error_data->message));
memset(isnull, false, sizeof(isnull));
values[0] = CStringGetTextDatum(escontext.error_data->message);
if (escontext.error_data->detail != NULL)
values[1] = CStringGetTextDatum(escontext.error_data->detail);
else
isnull[1] = true;
if (escontext.error_data->hint != NULL)
values[2] = CStringGetTextDatum(escontext.error_data->hint);
else
isnull[2] = true;
sqlstate = unpack_sql_state(escontext.error_data->sqlerrcode);
values[3] = CStringGetTextDatum(sqlstate);
}
return HeapTupleGetDatum(heap_form_tuple(tupdesc, values, isnull));
}
/* Common subroutine for the above */

10
src/include/catalog/pg_proc.dat
View File

@ -7118,9 +7118,13 @@
proname => 'pg_input_is_valid', provolatile => 's', prorettype => 'bool',
proargtypes => 'text text', prosrc => 'pg_input_is_valid' },
{ oid => '8051',
descr => 'get error message if string is not valid input for data type',
proname => 'pg_input_error_message', provolatile => 's', prorettype => 'text',
proargtypes => 'text text', prosrc => 'pg_input_error_message' },
descr => 'get error details if string is not valid input for data type',
proname => 'pg_input_error_info', provolatile => 's', prorettype => 'record',
proargtypes => 'text text',
proallargtypes => '{text,text,text,text,text,text}',
proargmodes => '{i,i,o,o,o,o}',
proargnames => '{value,type_name,message,detail,hint,sql_error_code}',
prosrc => 'pg_input_error_info' },
{ oid => '1268',
descr => 'parse qualified identifier to array of identifiers',

8
src/test/regress/expected/arrays.out
View File

@ -201,10 +201,10 @@ SELECT pg_input_is_valid('{1,zed}', 'integer[]');
f
(1 row)
SELECT pg_input_error_message('{1,zed}', 'integer[]');
pg_input_error_message
----------------------------------------------
invalid input syntax for type integer: "zed"
SELECT * FROM pg_input_error_info('{1,zed}', 'integer[]');
message | detail | hint | sql_error_code
----------------------------------------------+--------+------+----------------
invalid input syntax for type integer: "zed" | | | 22P02
(1 row)
-- test mixed slice/scalar subscripting

40
src/test/regress/expected/bit.out
View File

@ -753,10 +753,10 @@ SELECT pg_input_is_valid('01010001', 'bit(10)');
f
(1 row)
SELECT pg_input_error_message('01010001', 'bit(10)');
pg_input_error_message
-------------------------------------------------
bit string length 8 does not match type bit(10)
SELECT * FROM pg_input_error_info('01010001', 'bit(10)');
message | detail | hint | sql_error_code
-------------------------------------------------+--------+------+----------------
bit string length 8 does not match type bit(10) | | | 22026
(1 row)
SELECT pg_input_is_valid('01010Z01', 'bit(8)');
@ -765,10 +765,10 @@ SELECT pg_input_is_valid('01010Z01', 'bit(8)');
f
(1 row)
SELECT pg_input_error_message('01010Z01', 'bit(8)');
pg_input_error_message
---------------------------------
"Z" is not a valid binary digit
SELECT * FROM pg_input_error_info('01010Z01', 'bit(8)');
message | detail | hint | sql_error_code
---------------------------------+--------+------+----------------
"Z" is not a valid binary digit | | | 22P02
(1 row)
SELECT pg_input_is_valid('x01010Z01', 'bit(32)');
@ -777,10 +777,10 @@ SELECT pg_input_is_valid('x01010Z01', 'bit(32)');
f
(1 row)
SELECT pg_input_error_message('x01010Z01', 'bit(32)');
pg_input_error_message
--------------------------------------
"Z" is not a valid hexadecimal digit
SELECT * FROM pg_input_error_info('x01010Z01', 'bit(32)');
message | detail | hint | sql_error_code
--------------------------------------+--------+------+----------------
"Z" is not a valid hexadecimal digit | | | 22P02
(1 row)
SELECT pg_input_is_valid('01010Z01', 'varbit');
@ -789,10 +789,10 @@ SELECT pg_input_is_valid('01010Z01', 'varbit');
f
(1 row)
SELECT pg_input_error_message('01010Z01', 'varbit');
pg_input_error_message
---------------------------------
"Z" is not a valid binary digit
SELECT * FROM pg_input_error_info('01010Z01', 'varbit');
message | detail | hint | sql_error_code
---------------------------------+--------+------+----------------
"Z" is not a valid binary digit | | | 22P02
(1 row)
SELECT pg_input_is_valid('x01010Z01', 'varbit');
@ -801,9 +801,9 @@ SELECT pg_input_is_valid('x01010Z01', 'varbit');
f
(1 row)
SELECT pg_input_error_message('x01010Z01', 'varbit');
pg_input_error_message
--------------------------------------
"Z" is not a valid hexadecimal digit
SELECT * FROM pg_input_error_info('x01010Z01', 'varbit');
message | detail | hint | sql_error_code
--------------------------------------+--------+------+----------------
"Z" is not a valid hexadecimal digit | | | 22P02
(1 row)

8
src/test/regress/expected/boolean.out
View File

@ -155,10 +155,10 @@ SELECT pg_input_is_valid('asdf', 'bool');
f
(1 row)
SELECT pg_input_error_message('junk', 'bool');
pg_input_error_message
-----------------------------------------------
invalid input syntax for type boolean: "junk"
SELECT * FROM pg_input_error_info('junk', 'bool');
message | detail | hint | sql_error_code
-----------------------------------------------+--------+------+----------------
invalid input syntax for type boolean: "junk" | | | 22P02
(1 row)
-- and, or, not in qualifications

16
src/test/regress/expected/box.out
View File

@ -646,10 +646,10 @@ SELECT pg_input_is_valid('200', 'box');
f
(1 row)
SELECT pg_input_error_message('200', 'box');
pg_input_error_message
------------------------------------------
invalid input syntax for type box: "200"
SELECT * FROM pg_input_error_info('200', 'box');
message | detail | hint | sql_error_code
------------------------------------------+--------+------+----------------
invalid input syntax for type box: "200" | | | 22P02
(1 row)
SELECT pg_input_is_valid('((200,300),(500, xyz))', 'box');
@ -658,9 +658,9 @@ SELECT pg_input_is_valid('((200,300),(500, xyz))', 'box');
f
(1 row)
SELECT pg_input_error_message('((200,300),(500, xyz))', 'box');
pg_input_error_message
-------------------------------------------------------------
invalid input syntax for type box: "((200,300),(500, xyz))"
SELECT * FROM pg_input_error_info('((200,300),(500, xyz))', 'box');
message | detail | hint | sql_error_code
-------------------------------------------------------------+--------+------+----------------
invalid input syntax for type box: "((200,300),(500, xyz))" | | | 22P02
(1 row)

8
src/test/regress/expected/char.out
View File

@ -132,10 +132,10 @@ SELECT pg_input_is_valid('abcde', 'char(4)');
f
(1 row)
SELECT pg_input_error_message('abcde', 'char(4)');
pg_input_error_message
--------------------------------------
value too long for type character(4)
SELECT * FROM pg_input_error_info('abcde', 'char(4)');
message | detail | hint | sql_error_code
--------------------------------------+--------+------+----------------
value too long for type character(4) | | | 22001
(1 row)
--

8
src/test/regress/expected/char_1.out
View File

@ -132,10 +132,10 @@ SELECT pg_input_is_valid('abcde', 'char(4)');
f
(1 row)
SELECT pg_input_error_message('abcde', 'char(4)');
pg_input_error_message
--------------------------------------
value too long for type character(4)
SELECT * FROM pg_input_error_info('abcde', 'char(4)');
message | detail | hint | sql_error_code
--------------------------------------+--------+------+----------------
value too long for type character(4) | | | 22001
(1 row)
--

8
src/test/regress/expected/char_2.out
View File

@ -132,10 +132,10 @@ SELECT pg_input_is_valid('abcde', 'char(4)');
f
(1 row)
SELECT pg_input_error_message('abcde', 'char(4)');
pg_input_error_message
--------------------------------------
value too long for type character(4)
SELECT * FROM pg_input_error_info('abcde', 'char(4)');
message | detail | hint | sql_error_code
--------------------------------------+--------+------+----------------
value too long for type character(4) | | | 22001
(1 row)
--

16
src/test/regress/expected/date.out
View File

@ -859,16 +859,16 @@ SELECT pg_input_is_valid('6874898-01-01', 'date');
f
(1 row)
SELECT pg_input_error_message('garbage', 'date');
pg_input_error_message
-----------------------------------------------
invalid input syntax for type date: "garbage"
SELECT * FROM pg_input_error_info('garbage', 'date');
message | detail | hint | sql_error_code
-----------------------------------------------+--------+------+----------------
invalid input syntax for type date: "garbage" | | | 22007
(1 row)
SELECT pg_input_error_message('6874898-01-01', 'date');
pg_input_error_message
------------------------------------
date out of range: "6874898-01-01"
SELECT * FROM pg_input_error_info('6874898-01-01', 'date');
message | detail | hint | sql_error_code
------------------------------------+--------+------+----------------
date out of range: "6874898-01-01" | | | 22008
(1 row)
RESET datestyle;

34
src/test/regress/expected/domain.out
View File

@ -108,32 +108,32 @@ select pg_input_is_valid('-1', 'positiveint');
f
(1 row)
select pg_input_error_message('junk', 'positiveint');
pg_input_error_message
-----------------------------------------------
invalid input syntax for type integer: "junk"
select * from pg_input_error_info('junk', 'positiveint');
message | detail | hint | sql_error_code
-----------------------------------------------+--------+------+----------------
invalid input syntax for type integer: "junk" | | | 22P02
(1 row)
select pg_input_error_message('-1', 'positiveint');
pg_input_error_message
----------------------------------------------------------------------------
value for domain positiveint violates check constraint "positiveint_check"
select * from pg_input_error_info('-1', 'positiveint');
message | detail | hint | sql_error_code
----------------------------------------------------------------------------+--------+------+----------------
value for domain positiveint violates check constraint "positiveint_check" | | | 23514
(1 row)
select pg_input_error_message('junk', 'weirdfloat');
pg_input_error_message
--------------------------------------------------------
invalid input syntax for type double precision: "junk"
select * from pg_input_error_info('junk', 'weirdfloat');
message | detail | hint | sql_error_code
--------------------------------------------------------+--------+------+----------------
invalid input syntax for type double precision: "junk" | | | 22P02
(1 row)
select pg_input_error_message('0.01', 'weirdfloat');
pg_input_error_message
--------------------------------------------------------------------------
value for domain weirdfloat violates check constraint "weirdfloat_check"
select * from pg_input_error_info('0.01', 'weirdfloat');
message | detail | hint | sql_error_code
--------------------------------------------------------------------------+--------+------+----------------
value for domain weirdfloat violates check constraint "weirdfloat_check" | | | 23514
(1 row)
-- We currently can't trap errors raised in the CHECK expression itself
select pg_input_error_message('0', 'weirdfloat');
select * from pg_input_error_info('0', 'weirdfloat');
ERROR: division by zero
drop domain positiveint;
drop domain weirdfloat;

21
src/test/regress/expected/enum.out
View File

@ -37,18 +37,21 @@ SELECT pg_input_is_valid('mauve', 'rainbow');
f
(1 row)
SELECT pg_input_error_message('mauve', 'rainbow');
pg_input_error_message
-----------------------------------------------
invalid input value for enum rainbow: "mauve"
SELECT * FROM pg_input_error_info('mauve', 'rainbow');
message | detail | hint | sql_error_code
-----------------------------------------------+--------+------+----------------
invalid input value for enum rainbow: "mauve" | | | 22P02
(1 row)
SELECT pg_input_error_message(repeat('too_long', 32), 'rainbow');
pg_input_error_message
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
invalid input value for enum rainbow: "too_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_long"
(1 row)
\x
SELECT * FROM pg_input_error_info(repeat('too_long', 32), 'rainbow');
-[ RECORD 1 ]--+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
message | invalid input value for enum rainbow: "too_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_longtoo_long"
detail |
hint |
sql_error_code | 22P02
\x
--
-- adding new values
--

8
src/test/regress/expected/float4-misrounded-input.out
View File

@ -100,10 +100,10 @@ SELECT pg_input_is_valid('1e400', 'float4');
f
(1 row)
SELECT pg_input_error_message('1e400', 'float4');
pg_input_error_message
---------------------------------------
"1e400" is out of range for type real
SELECT * FROM pg_input_error_info('1e400', 'float4');
message | detail | hint | sql_error_code
---------------------------------------+--------+------+----------------
"1e400" is out of range for type real | | | 22003
(1 row)
-- special inputs

8
src/test/regress/expected/float4.out
View File

@ -100,10 +100,10 @@ SELECT pg_input_is_valid('1e400', 'float4');
f
(1 row)
SELECT pg_input_error_message('1e400', 'float4');
pg_input_error_message
---------------------------------------
"1e400" is out of range for type real
SELECT * FROM pg_input_error_info('1e400', 'float4');
message | detail | hint | sql_error_code
---------------------------------------+--------+------+----------------
"1e400" is out of range for type real | | | 22003
(1 row)
-- special inputs

8
src/test/regress/expected/float8.out
View File

@ -87,10 +87,10 @@ SELECT pg_input_is_valid('1e4000', 'float8');
f
(1 row)
SELECT pg_input_error_message('1e4000', 'float8');
pg_input_error_message
----------------------------------------------------
"1e4000" is out of range for type double precision
SELECT * FROM pg_input_error_info('1e4000', 'float8');
message | detail | hint | sql_error_code
----------------------------------------------------+--------+------+----------------
"1e4000" is out of range for type double precision | | | 22003
(1 row)
-- special inputs

16
src/test/regress/expected/geometry.out
View File

@ -5302,10 +5302,10 @@ SELECT pg_input_is_valid('(1', 'circle');
f
(1 row)
SELECT pg_input_error_message('1,', 'circle');
pg_input_error_message
--------------------------------------------
invalid input syntax for type circle: "1,"
SELECT * FROM pg_input_error_info('1,', 'circle');
message | detail | hint | sql_error_code
--------------------------------------------+--------+------+----------------
invalid input syntax for type circle: "1," | | | 22P02
(1 row)
SELECT pg_input_is_valid('(1,2),-1', 'circle');
@ -5314,9 +5314,9 @@ SELECT pg_input_is_valid('(1,2),-1', 'circle');
f
(1 row)
SELECT pg_input_error_message('(1,2),-1', 'circle');
pg_input_error_message
--------------------------------------------------
invalid input syntax for type circle: "(1,2),-1"
SELECT * FROM pg_input_error_info('(1,2),-1', 'circle');
message | detail | hint | sql_error_code
--------------------------------------------------+--------+------+----------------
invalid input syntax for type circle: "(1,2),-1" | | | 22P02
(1 row)

24
src/test/regress/expected/inet.out
View File

@ -1063,10 +1063,10 @@ SELECT pg_input_is_valid('1234', 'cidr');
f
(1 row)
SELECT pg_input_error_message('1234', 'cidr');
pg_input_error_message
--------------------------------------------
invalid input syntax for type cidr: "1234"
SELECT * FROM pg_input_error_info('1234', 'cidr');
message | detail | hint | sql_error_code
--------------------------------------------+--------+------+----------------
invalid input syntax for type cidr: "1234" | | | 22P02
(1 row)
SELECT pg_input_is_valid('192.168.198.200/24', 'cidr');
@ -1075,10 +1075,10 @@ SELECT pg_input_is_valid('192.168.198.200/24', 'cidr');
f
(1 row)
SELECT pg_input_error_message('192.168.198.200/24', 'cidr');
pg_input_error_message
------------------------------------------
invalid cidr value: "192.168.198.200/24"
SELECT * FROM pg_input_error_info('192.168.198.200/24', 'cidr');
message | detail | hint | sql_error_code
------------------------------------------+--------------------------------------+------+----------------
invalid cidr value: "192.168.198.200/24" | Value has bits set to right of mask. | | 22P02
(1 row)
SELECT pg_input_is_valid('1234', 'inet');
@ -1087,9 +1087,9 @@ SELECT pg_input_is_valid('1234', 'inet');
f
(1 row)
SELECT pg_input_error_message('1234', 'inet');
pg_input_error_message
--------------------------------------------
invalid input syntax for type inet: "1234"
SELECT * FROM pg_input_error_info('1234', 'inet');
message | detail | hint | sql_error_code
--------------------------------------------+--------+------+----------------
invalid input syntax for type inet: "1234" | | | 22P02
(1 row)

24
src/test/regress/expected/int2.out
View File

@ -64,10 +64,10 @@ SELECT pg_input_is_valid('50000', 'int2');
f
(1 row)
SELECT pg_input_error_message('50000', 'int2');
pg_input_error_message
-------------------------------------------------
value "50000" is out of range for type smallint
SELECT * FROM pg_input_error_info('50000', 'int2');
message | detail | hint | sql_error_code
-------------------------------------------------+--------+------+----------------
value "50000" is out of range for type smallint | | | 22003
(1 row)
-- While we're here, check int2vector as well
@ -77,16 +77,16 @@ SELECT pg_input_is_valid(' 1 3 5 ', 'int2vector');
t
(1 row)
SELECT pg_input_error_message('1 asdf', 'int2vector');
pg_input_error_message
------------------------------------------------
invalid input syntax for type smallint: "asdf"
SELECT * FROM pg_input_error_info('1 asdf', 'int2vector');
message | detail | hint | sql_error_code
------------------------------------------------+--------+------+----------------
invalid input syntax for type smallint: "asdf" | | | 22P02
(1 row)
SELECT pg_input_error_message('50000', 'int2vector');
pg_input_error_message
-------------------------------------------------
value "50000" is out of range for type smallint
SELECT * FROM pg_input_error_info('50000', 'int2vector');
message | detail | hint | sql_error_code
-------------------------------------------------+--------+------+----------------
value "50000" is out of range for type smallint | | | 22003
(1 row)
SELECT * FROM INT2_TBL AS f(a, b);

8
src/test/regress/expected/int4.out
View File

@ -64,10 +64,10 @@ SELECT pg_input_is_valid('1000000000000', 'int4');
f
(1 row)
SELECT pg_input_error_message('1000000000000', 'int4');
pg_input_error_message
--------------------------------------------------------
value "1000000000000" is out of range for type integer
SELECT * FROM pg_input_error_info('1000000000000', 'int4');
message | detail | hint | sql_error_code
--------------------------------------------------------+--------+------+----------------
value "1000000000000" is out of range for type integer | | | 22003
(1 row)
SELECT i.* FROM INT4_TBL i WHERE i.f1 <> int2 '0';

8
src/test/regress/expected/int8.out
View File

@ -61,10 +61,10 @@ SELECT pg_input_is_valid('10000000000000000000', 'int8');
f
(1 row)
SELECT pg_input_error_message('10000000000000000000', 'int8');
pg_input_error_message
--------------------------------------------------------------
value "10000000000000000000" is out of range for type bigint
SELECT * FROM pg_input_error_info('10000000000000000000', 'int8');
message | detail | hint | sql_error_code
--------------------------------------------------------------+--------+------+----------------
value "10000000000000000000" is out of range for type bigint | | | 22003
(1 row)
-- int8/int8 cmp

16
src/test/regress/expected/interval.out
View File

@ -91,16 +91,16 @@ SELECT pg_input_is_valid('@ 30 eons ago', 'interval');
f
(1 row)
SELECT pg_input_error_message('garbage', 'interval');
pg_input_error_message
---------------------------------------------------
invalid input syntax for type interval: "garbage"
SELECT * FROM pg_input_error_info('garbage', 'interval');
message | detail | hint | sql_error_code
---------------------------------------------------+--------+------+----------------
invalid input syntax for type interval: "garbage" | | | 22007
(1 row)
SELECT pg_input_error_message('@ 30 eons ago', 'interval');
pg_input_error_message
---------------------------------------------------------
invalid input syntax for type interval: "@ 30 eons ago"
SELECT * FROM pg_input_error_info('@ 30 eons ago', 'interval');
message | detail | hint | sql_error_code
---------------------------------------------------------+--------+------+----------------
invalid input syntax for type interval: "@ 30 eons ago" | | | 22007
(1 row)
-- test interval operators

8
src/test/regress/expected/json.out
View File

@ -333,10 +333,10 @@ select pg_input_is_valid('{"a":true', 'json');
f
(1 row)
select pg_input_error_message('{"a":true', 'json');
pg_input_error_message
------------------------------------
invalid input syntax for type json
select * from pg_input_error_info('{"a":true', 'json');
message | detail | hint | sql_error_code
------------------------------------+--------------------------------------+------+----------------
invalid input syntax for type json | The input string ended unexpectedly. | | 22P02
(1 row)
--constructors

8
src/test/regress/expected/json_encoding.out
View File

@ -261,9 +261,9 @@ SELECT jsonb '{ "a": "null \\u0000 escape" }' ->> 'a' as not_an_escape;
(1 row)
-- soft error for input-time failure
select pg_input_error_message('{ "a": "\ud83d\ude04\ud83d\udc36" }', 'jsonb');
pg_input_error_message
------------------------
select * from pg_input_error_info('{ "a": "\ud83d\ude04\ud83d\udc36" }', 'jsonb');
message | detail | hint | sql_error_code
---------+--------+------+----------------
| | |
(1 row)

8
src/test/regress/expected/json_encoding_1.out
View File

@ -257,9 +257,9 @@ SELECT jsonb '{ "a": "null \\u0000 escape" }' ->> 'a' as not_an_escape;
(1 row)
-- soft error for input-time failure
select pg_input_error_message('{ "a": "\ud83d\ude04\ud83d\udc36" }', 'jsonb');
pg_input_error_message
-------------------------------------
unsupported Unicode escape sequence
select * from pg_input_error_info('{ "a": "\ud83d\ude04\ud83d\udc36" }', 'jsonb');
message | detail | hint | sql_error_code
-------------------------------------+----------------------------------------------------------------------------------+------+----------------
unsupported Unicode escape sequence | Unicode escape value could not be translated to the server's encoding SQL_ASCII. | | 22P05
(1 row)

16
src/test/regress/expected/jsonb.out
View File

@ -323,16 +323,16 @@ select pg_input_is_valid('{"a":true', 'jsonb');
f
(1 row)
select pg_input_error_message('{"a":true', 'jsonb');
pg_input_error_message
------------------------------------
invalid input syntax for type json
select * from pg_input_error_info('{"a":true', 'jsonb');
message | detail | hint | sql_error_code
------------------------------------+--------------------------------------+------+----------------
invalid input syntax for type json | The input string ended unexpectedly. | | 22P02
(1 row)
select pg_input_error_message('{"a":1e1000000}', 'jsonb');
pg_input_error_message
--------------------------------
value overflows numeric format
select * from pg_input_error_info('{"a":1e1000000}', 'jsonb');
message | detail | hint | sql_error_code
--------------------------------+--------+------+----------------
value overflows numeric format | | | 22003
(1 row)
-- make sure jsonb is passed through json generators without being escaped

22
src/test/regress/expected/jsonpath.out
View File

@ -1035,18 +1035,22 @@ select '1?(2>3)'::jsonpath;
-- test non-error-throwing API
SELECT str as jsonpath,
pg_input_is_valid(str,'jsonpath') as ok,
pg_input_error_message(str,'jsonpath') as errmsg
errinfo.sql_error_code,
errinfo.message,
errinfo.detail,
errinfo.hint
FROM unnest(ARRAY['$ ? (@ like_regex "pattern" flag "smixq")'::text,
'$ ? (@ like_regex "pattern" flag "a")',
'@ + 1',
'00',
'1a']) str;
jsonpath | ok | errmsg
-------------------------------------------+----+-----------------------------------------------------------------------
$ ? (@ like_regex "pattern" flag "smixq") | t |
$ ? (@ like_regex "pattern" flag "a") | f | invalid input syntax for type jsonpath
@ + 1 | f | @ is not allowed in root expressions
00 | f | trailing junk after numeric literal at or near "00" of jsonpath input
1a | f | trailing junk after numeric literal at or near "1a" of jsonpath input
'1a']) str,
LATERAL pg_input_error_info(str, 'jsonpath') as errinfo;
jsonpath | ok | sql_error_code | message | detail | hint
-------------------------------------------+----+----------------+-----------------------------------------------------------------------+----------------------------------------------------------+------
$ ? (@ like_regex "pattern" flag "smixq") | t | | | |
$ ? (@ like_regex "pattern" flag "a") | f | 42601 | invalid input syntax for type jsonpath | Unrecognized flag character "a" in LIKE_REGEX predicate. |
@ + 1 | f | 42601 | @ is not allowed in root expressions | |
00 | f | 42601 | trailing junk after numeric literal at or near "00" of jsonpath input | |
1a | f | 42601 | trailing junk after numeric literal at or near "1a" of jsonpath input | |
(5 rows)

40
src/test/regress/expected/line.out
View File

@ -92,10 +92,10 @@ SELECT pg_input_is_valid('{1, 1}', 'line');
f
(1 row)
SELECT pg_input_error_message('{1, 1}', 'line');
pg_input_error_message
----------------------------------------------
invalid input syntax for type line: "{1, 1}"
SELECT * FROM pg_input_error_info('{1, 1}', 'line');
message | detail | hint | sql_error_code
----------------------------------------------+--------+------+----------------
invalid input syntax for type line: "{1, 1}" | | | 22P02
(1 row)
SELECT pg_input_is_valid('{0, 0, 0}', 'line');
@ -104,10 +104,10 @@ SELECT pg_input_is_valid('{0, 0, 0}', 'line');
f
(1 row)
SELECT pg_input_error_message('{0, 0, 0}', 'line');
pg_input_error_message
---------------------------------------------------------
invalid line specification: A and B cannot both be zero
SELECT * FROM pg_input_error_info('{0, 0, 0}', 'line');
message | detail | hint | sql_error_code
---------------------------------------------------------+--------+------+----------------
invalid line specification: A and B cannot both be zero | | | 22P02
(1 row)
SELECT pg_input_is_valid('{1, 1, a}', 'line');
@ -116,10 +116,10 @@ SELECT pg_input_is_valid('{1, 1, a}', 'line');
f
(1 row)
SELECT pg_input_error_message('{1, 1, a}', 'line');
pg_input_error_message
-------------------------------------------------
invalid input syntax for type line: "{1, 1, a}"
SELECT * FROM pg_input_error_info('{1, 1, a}', 'line');
message | detail | hint | sql_error_code
-------------------------------------------------+--------+------+----------------
invalid input syntax for type line: "{1, 1, a}" | | | 22P02
(1 row)
SELECT pg_input_is_valid('{1, 1, 1e400}', 'line');
@ -128,10 +128,10 @@ SELECT pg_input_is_valid('{1, 1, 1e400}', 'line');
f
(1 row)
SELECT pg_input_error_message('{1, 1, 1e400}', 'line');
pg_input_error_message
---------------------------------------------------
"1e400" is out of range for type double precision
SELECT * FROM pg_input_error_info('{1, 1, 1e400}', 'line');
message | detail | hint | sql_error_code
---------------------------------------------------+--------+------+----------------
"1e400" is out of range for type double precision | | | 22003
(1 row)
SELECT pg_input_is_valid('(1, 1), (1, 1e400)', 'line');
@ -140,9 +140,9 @@ SELECT pg_input_is_valid('(1, 1), (1, 1e400)', 'line');
f
(1 row)
SELECT pg_input_error_message('(1, 1), (1, 1e400)', 'line');
pg_input_error_message
---------------------------------------------------
"1e400" is out of range for type double precision
SELECT * FROM pg_input_error_info('(1, 1), (1, 1e400)', 'line');
message | detail | hint | sql_error_code
---------------------------------------------------+--------+------+----------------
"1e400" is out of range for type double precision | | | 22003
(1 row)

8
src/test/regress/expected/lseg.out
View File

@ -49,9 +49,9 @@ SELECT pg_input_is_valid('[(1,2),(3)]', 'lseg');
f
(1 row)
SELECT pg_input_error_message('[(1,2),(3)]', 'lseg');
pg_input_error_message
---------------------------------------------------
invalid input syntax for type lseg: "[(1,2),(3)]"
SELECT * FROM pg_input_error_info('[(1,2),(3)]', 'lseg');
message | detail | hint | sql_error_code
---------------------------------------------------+--------+------+----------------
invalid input syntax for type lseg: "[(1,2),(3)]" | | | 22P02
(1 row)

16
src/test/regress/expected/macaddr.out
View File

@ -165,10 +165,10 @@ SELECT pg_input_is_valid('08:00:2b:01:02:ZZ', 'macaddr');
f
(1 row)
SELECT pg_input_error_message('08:00:2b:01:02:ZZ', 'macaddr');
pg_input_error_message
------------------------------------------------------------
invalid input syntax for type macaddr: "08:00:2b:01:02:ZZ"
SELECT * FROM pg_input_error_info('08:00:2b:01:02:ZZ', 'macaddr');
message | detail | hint | sql_error_code
------------------------------------------------------------+--------+------+----------------
invalid input syntax for type macaddr: "08:00:2b:01:02:ZZ" | | | 22P02
(1 row)
SELECT pg_input_is_valid('08:00:2b:01:02:', 'macaddr');
@ -177,9 +177,9 @@ SELECT pg_input_is_valid('08:00:2b:01:02:', 'macaddr');
f
(1 row)
SELECT pg_input_error_message('08:00:2b:01:02:', 'macaddr');
pg_input_error_message
----------------------------------------------------------
invalid input syntax for type macaddr: "08:00:2b:01:02:"
SELECT * FROM pg_input_error_info('08:00:2b:01:02:', 'macaddr');
message | detail | hint | sql_error_code
----------------------------------------------------------+--------+------+----------------
invalid input syntax for type macaddr: "08:00:2b:01:02:" | | | 22P02
(1 row)

16
src/test/regress/expected/macaddr8.out
View File

@ -359,10 +359,10 @@ SELECT pg_input_is_valid('08:00:2b:01:02:03:04:ZZ', 'macaddr8');
f
(1 row)
SELECT pg_input_error_message('08:00:2b:01:02:03:04:ZZ', 'macaddr8');
pg_input_error_message
-------------------------------------------------------------------
invalid input syntax for type macaddr8: "08:00:2b:01:02:03:04:ZZ"
SELECT * FROM pg_input_error_info('08:00:2b:01:02:03:04:ZZ', 'macaddr8');
message | detail | hint | sql_error_code
-------------------------------------------------------------------+--------+------+----------------
invalid input syntax for type macaddr8: "08:00:2b:01:02:03:04:ZZ" | | | 22P02
(1 row)
SELECT pg_input_is_valid('08:00:2b:01:02:03:04:', 'macaddr8');
@ -371,9 +371,9 @@ SELECT pg_input_is_valid('08:00:2b:01:02:03:04:', 'macaddr8');
f
(1 row)
SELECT pg_input_error_message('08:00:2b:01:02:03:04:', 'macaddr8');
pg_input_error_message
-----------------------------------------------------------------
invalid input syntax for type macaddr8: "08:00:2b:01:02:03:04:"
SELECT * FROM pg_input_error_info('08:00:2b:01:02:03:04:', 'macaddr8');
message | detail | hint | sql_error_code
-----------------------------------------------------------------+--------+------+----------------
invalid input syntax for type macaddr8: "08:00:2b:01:02:03:04:" | | | 22P02
(1 row)

16
src/test/regress/expected/money.out
View File

@ -338,10 +338,10 @@ SELECT pg_input_is_valid('\x0001', 'money');
f
(1 row)
SELECT pg_input_error_message('\x0001', 'money');
pg_input_error_message
-----------------------------------------------
invalid input syntax for type money: "\x0001"
SELECT * FROM pg_input_error_info('\x0001', 'money');
message | detail | hint | sql_error_code
-----------------------------------------------+--------+------+----------------
invalid input syntax for type money: "\x0001" | | | 22P02
(1 row)
SELECT pg_input_is_valid('192233720368547758.07', 'money');
@ -350,10 +350,10 @@ SELECT pg_input_is_valid('192233720368547758.07', 'money');
f
(1 row)
SELECT pg_input_error_message('192233720368547758.07', 'money');
pg_input_error_message
--------------------------------------------------------------
value "192233720368547758.07" is out of range for type money
SELECT * FROM pg_input_error_info('192233720368547758.07', 'money');
message | detail | hint | sql_error_code
--------------------------------------------------------------+--------+------+----------------
value "192233720368547758.07" is out of range for type money | | | 22003
(1 row)
-- documented minimums and maximums

16
src/test/regress/expected/multirangetypes.out
View File

@ -287,10 +287,10 @@ select pg_input_is_valid('{[1,2], [4,5]', 'int4multirange');
f
(1 row)
select pg_input_error_message('{[1,2], [4,5]', 'int4multirange');
pg_input_error_message
-----------------------------------------------
malformed multirange literal: "{[1,2], [4,5]"
select * from pg_input_error_info('{[1,2], [4,5]', 'int4multirange');
message | detail | hint | sql_error_code
-----------------------------------------------+--------------------------+------+----------------
malformed multirange literal: "{[1,2], [4,5]" | Unexpected end of input. | | 22P02
(1 row)
select pg_input_is_valid('{[1,2], [4,zed]}', 'int4multirange');
@ -299,10 +299,10 @@ select pg_input_is_valid('{[1,2], [4,zed]}', 'int4multirange');
f
(1 row)
select pg_input_error_message('{[1,2], [4,zed]}', 'int4multirange');
pg_input_error_message
----------------------------------------------
invalid input syntax for type integer: "zed"
select * from pg_input_error_info('{[1,2], [4,zed]}', 'int4multirange');
message | detail | hint | sql_error_code
----------------------------------------------+--------+------+----------------
invalid input syntax for type integer: "zed" | | | 22P02
(1 row)
--

24
src/test/regress/expected/numeric.out
View File

@ -2312,10 +2312,10 @@ SELECT pg_input_is_valid('1e400000', 'numeric');
f
(1 row)
SELECT pg_input_error_message('1e400000', 'numeric');
pg_input_error_message
--------------------------------
value overflows numeric format
SELECT * FROM pg_input_error_info('1e400000', 'numeric');
message | detail | hint | sql_error_code
--------------------------------+--------+------+----------------
value overflows numeric format | | | 22003
(1 row)
SELECT pg_input_is_valid('1234.567', 'numeric(8,4)');
@ -2330,16 +2330,16 @@ SELECT pg_input_is_valid('1234.567', 'numeric(7,4)');
f
(1 row)
SELECT pg_input_error_message('1234.567', 'numeric(7,4)');
pg_input_error_message
------------------------
numeric field overflow
SELECT * FROM pg_input_error_info('1234.567', 'numeric(7,4)');
message | detail | hint | sql_error_code
------------------------+-----------------------------------------------------------------------------------+------+----------------
numeric field overflow | A field with precision 7, scale 4 must round to an absolute value less than 10^3. | | 22003
(1 row)
SELECT pg_input_error_message('0x1234.567', 'numeric');
pg_input_error_message
-----------------------------------------------------
invalid input syntax for type numeric: "0x1234.567"
SELECT * FROM pg_input_error_info('0x1234.567', 'numeric');
message | detail | hint | sql_error_code
-----------------------------------------------------+--------+------+----------------
invalid input syntax for type numeric: "0x1234.567" | | | 22P02
(1 row)
--

32
src/test/regress/expected/oid.out
View File

@ -78,10 +78,10 @@ SELECT pg_input_is_valid('01XYZ', 'oid');
f
(1 row)
SELECT pg_input_error_message('01XYZ', 'oid');
pg_input_error_message
--------------------------------------------
invalid input syntax for type oid: "01XYZ"
SELECT * FROM pg_input_error_info('01XYZ', 'oid');
message | detail | hint | sql_error_code
--------------------------------------------+--------+------+----------------
invalid input syntax for type oid: "01XYZ" | | | 22P02
(1 row)
SELECT pg_input_is_valid('9999999999', 'oid');
@ -90,10 +90,10 @@ SELECT pg_input_is_valid('9999999999', 'oid');
f
(1 row)
SELECT pg_input_error_message('9999999999', 'oid');
pg_input_error_message
-------------------------------------------------
value "9999999999" is out of range for type oid
SELECT * FROM pg_input_error_info('9999999999', 'oid');
message | detail | hint | sql_error_code
-------------------------------------------------+--------+------+----------------
value "9999999999" is out of range for type oid | | | 22003
(1 row)
-- While we're here, check oidvector as well
@ -109,10 +109,10 @@ SELECT pg_input_is_valid('01 01XYZ', 'oidvector');
f
(1 row)
SELECT pg_input_error_message('01 01XYZ', 'oidvector');
pg_input_error_message
------------------------------------------
invalid input syntax for type oid: "XYZ"
SELECT * FROM pg_input_error_info('01 01XYZ', 'oidvector');
message | detail | hint | sql_error_code
------------------------------------------+--------+------+----------------
invalid input syntax for type oid: "XYZ" | | | 22P02
(1 row)
SELECT pg_input_is_valid('01 9999999999', 'oidvector');
@ -121,10 +121,10 @@ SELECT pg_input_is_valid('01 9999999999', 'oidvector');
f
(1 row)
SELECT pg_input_error_message('01 9999999999', 'oidvector');
pg_input_error_message
-------------------------------------------------
value "9999999999" is out of range for type oid
SELECT * FROM pg_input_error_info('01 9999999999', 'oidvector');
message | detail | hint | sql_error_code
-------------------------------------------------+--------+------+----------------
value "9999999999" is out of range for type oid | | | 22003
(1 row)
SELECT o.* FROM OID_TBL o WHERE o.f1 = 1234;

16
src/test/regress/expected/path.out
View File

@ -87,10 +87,10 @@ SELECT pg_input_is_valid('[(1,2),(3)]', 'path');
f
(1 row)
SELECT pg_input_error_message('[(1,2),(3)]', 'path');
pg_input_error_message
---------------------------------------------------
invalid input syntax for type path: "[(1,2),(3)]"
SELECT * FROM pg_input_error_info('[(1,2),(3)]', 'path');
message | detail | hint | sql_error_code
---------------------------------------------------+--------+------+----------------
invalid input syntax for type path: "[(1,2),(3)]" | | | 22P02
(1 row)
SELECT pg_input_is_valid('[(1,2,6),(3,4,6)]', 'path');
@ -99,9 +99,9 @@ SELECT pg_input_is_valid('[(1,2,6),(3,4,6)]', 'path');
f
(1 row)
SELECT pg_input_error_message('[(1,2,6),(3,4,6)]', 'path');
pg_input_error_message
---------------------------------------------------------
invalid input syntax for type path: "[(1,2,6),(3,4,6)]"
SELECT * FROM pg_input_error_info('[(1,2,6),(3,4,6)]', 'path');
message | detail | hint | sql_error_code
---------------------------------------------------------+--------+------+----------------
invalid input syntax for type path: "[(1,2,6),(3,4,6)]" | | | 22P02
(1 row)

8
src/test/regress/expected/pg_lsn.out
View File

@ -33,10 +33,10 @@ SELECT pg_input_is_valid('16AE7F7', 'pg_lsn');
f
(1 row)
SELECT pg_input_error_message('16AE7F7', 'pg_lsn');
pg_input_error_message
-------------------------------------------------
invalid input syntax for type pg_lsn: "16AE7F7"
SELECT * FROM pg_input_error_info('16AE7F7', 'pg_lsn');
message | detail | hint | sql_error_code
-------------------------------------------------+--------+------+----------------
invalid input syntax for type pg_lsn: "16AE7F7" | | | 22P02
(1 row)
-- Min/Max aggregation

8
src/test/regress/expected/point.out
View File

@ -470,9 +470,9 @@ SELECT pg_input_is_valid('1,y', 'point');
f
(1 row)
SELECT pg_input_error_message('1,y', 'point');
pg_input_error_message
--------------------------------------------
invalid input syntax for type point: "1,y"
SELECT * FROM pg_input_error_info('1,y', 'point');
message | detail | hint | sql_error_code
--------------------------------------------+--------+------+----------------
invalid input syntax for type point: "1,y" | | | 22P02
(1 row)

16
src/test/regress/expected/polygon.out
View File

@ -313,10 +313,10 @@ SELECT pg_input_is_valid('(2.0,0.8,0.1)', 'polygon');
f
(1 row)
SELECT pg_input_error_message('(2.0,0.8,0.1)', 'polygon');
pg_input_error_message
--------------------------------------------------------
invalid input syntax for type polygon: "(2.0,0.8,0.1)"
SELECT * FROM pg_input_error_info('(2.0,0.8,0.1)', 'polygon');
message | detail | hint | sql_error_code
--------------------------------------------------------+--------+------+----------------
invalid input syntax for type polygon: "(2.0,0.8,0.1)" | | | 22P02
(1 row)
SELECT pg_input_is_valid('(2.0,xyz)', 'polygon');
@ -325,9 +325,9 @@ SELECT pg_input_is_valid('(2.0,xyz)', 'polygon');
f
(1 row)
SELECT pg_input_error_message('(2.0,xyz)', 'polygon');
pg_input_error_message
----------------------------------------------------
invalid input syntax for type polygon: "(2.0,xyz)"
SELECT * FROM pg_input_error_info('(2.0,xyz)', 'polygon');
message | detail | hint | sql_error_code
----------------------------------------------------+--------+------+----------------
invalid input syntax for type polygon: "(2.0,xyz)" | | | 22P02
(1 row)

24
src/test/regress/expected/privileges.out
View File

@ -2246,10 +2246,10 @@ SELECT pg_input_is_valid('regress_priv_user1=r/', 'aclitem');
f
(1 row)
SELECT pg_input_error_message('regress_priv_user1=r/', 'aclitem');
pg_input_error_message
---------------------------------
a name must follow the "/" sign
SELECT * FROM pg_input_error_info('regress_priv_user1=r/', 'aclitem');
message | detail | hint | sql_error_code
---------------------------------+--------+------+----------------
a name must follow the "/" sign | | | 22P02
(1 row)
SELECT pg_input_is_valid('regress_priv_user1=r/regress_no_such_user', 'aclitem');
@ -2258,10 +2258,10 @@ SELECT pg_input_is_valid('regress_priv_user1=r/regress_no_such_user', 'aclitem')
f
(1 row)
SELECT pg_input_error_message('regress_priv_user1=r/regress_no_such_user', 'aclitem');
pg_input_error_message
--------------------------------------------
role "regress_no_such_user" does not exist
SELECT * FROM pg_input_error_info('regress_priv_user1=r/regress_no_such_user', 'aclitem');
message | detail | hint | sql_error_code
--------------------------------------------+--------+------+----------------
role "regress_no_such_user" does not exist | | | 42704
(1 row)
SELECT pg_input_is_valid('regress_priv_user1=rY', 'aclitem');
@ -2270,10 +2270,10 @@ SELECT pg_input_is_valid('regress_priv_user1=rY', 'aclitem');
f
(1 row)
SELECT pg_input_error_message('regress_priv_user1=rY', 'aclitem');
pg_input_error_message
----------------------------------------------------------
invalid mode character: must be one of "arwdDxtXUCTcsAm"
SELECT * FROM pg_input_error_info('regress_priv_user1=rY', 'aclitem');
message | detail | hint | sql_error_code
----------------------------------------------------------+--------+------+----------------
invalid mode character: must be one of "arwdDxtXUCTcsAm" | | | 22P02
(1 row)
--

40
src/test/regress/expected/rangetypes.out
View File

@ -188,10 +188,10 @@ select pg_input_is_valid('(1,4', 'int4range');
f
(1 row)
select pg_input_error_message('(1,4', 'int4range');
pg_input_error_message
---------------------------------
malformed range literal: "(1,4"
select * from pg_input_error_info('(1,4', 'int4range');
message | detail | hint | sql_error_code
---------------------------------+--------------------------+------+----------------
malformed range literal: "(1,4" | Unexpected end of input. | | 22P02
(1 row)
select pg_input_is_valid('(4,1)', 'int4range');
@ -200,10 +200,10 @@ select pg_input_is_valid('(4,1)', 'int4range');
f
(1 row)
select pg_input_error_message('(4,1)', 'int4range');
pg_input_error_message
-------------------------------------------------------------------
range lower bound must be less than or equal to range upper bound
select * from pg_input_error_info('(4,1)', 'int4range');
message | detail | hint | sql_error_code
-------------------------------------------------------------------+--------+------+----------------
range lower bound must be less than or equal to range upper bound | | | 22000
(1 row)
select pg_input_is_valid('(4,zed)', 'int4range');
@ -212,10 +212,10 @@ select pg_input_is_valid('(4,zed)', 'int4range');
f
(1 row)
select pg_input_error_message('(4,zed)', 'int4range');
pg_input_error_message
----------------------------------------------
invalid input syntax for type integer: "zed"
select * from pg_input_error_info('(4,zed)', 'int4range');
message | detail | hint | sql_error_code
----------------------------------------------+--------+------+----------------
invalid input syntax for type integer: "zed" | | | 22P02
(1 row)
select pg_input_is_valid('[1,2147483647]', 'int4range');
@ -224,10 +224,10 @@ select pg_input_is_valid('[1,2147483647]', 'int4range');
f
(1 row)
select pg_input_error_message('[1,2147483647]', 'int4range');
pg_input_error_message
------------------------
integer out of range
select * from pg_input_error_info('[1,2147483647]', 'int4range');
message | detail | hint | sql_error_code
----------------------+--------+------+----------------
integer out of range | | | 22003
(1 row)
select pg_input_is_valid('[2000-01-01,5874897-12-31]', 'daterange');
@ -236,10 +236,10 @@ select pg_input_is_valid('[2000-01-01,5874897-12-31]', 'daterange');
f
(1 row)
select pg_input_error_message('[2000-01-01,5874897-12-31]', 'daterange');
pg_input_error_message
------------------------
date out of range
select * from pg_input_error_info('[2000-01-01,5874897-12-31]', 'daterange');
message | detail | hint | sql_error_code
-------------------+--------+------+----------------
date out of range | | | 22008
(1 row)
--

114
src/test/regress/expected/regproc.out
View File

@ -448,10 +448,10 @@ SELECT to_regnamespace('foo.bar');
(1 row)
-- Test soft-error API
SELECT pg_input_error_message('ng_catalog.pg_class', 'regclass');
pg_input_error_message
-----------------------------------------------
relation "ng_catalog.pg_class" does not exist
SELECT * FROM pg_input_error_info('ng_catalog.pg_class', 'regclass');
message | detail | hint | sql_error_code
-----------------------------------------------+--------+------+----------------
relation "ng_catalog.pg_class" does not exist | | | 42P01
(1 row)
SELECT pg_input_is_valid('ng_catalog."POSIX"', 'regcollation');
@ -460,87 +460,87 @@ SELECT pg_input_is_valid('ng_catalog."POSIX"', 'regcollation');
f
(1 row)
SELECT pg_input_error_message('no_such_config', 'regconfig');
pg_input_error_message
-----------------------------------------------------------
text search configuration "no_such_config" does not exist
SELECT * FROM pg_input_error_info('no_such_config', 'regconfig');
message | detail | hint | sql_error_code
-----------------------------------------------------------+--------+------+----------------
text search configuration "no_such_config" does not exist | | | 42704
(1 row)
SELECT pg_input_error_message('no_such_dictionary', 'regdictionary');
pg_input_error_message
------------------------------------------------------------
text search dictionary "no_such_dictionary" does not exist
SELECT * FROM pg_input_error_info('no_such_dictionary', 'regdictionary');
message | detail | hint | sql_error_code
------------------------------------------------------------+--------+------+----------------
text search dictionary "no_such_dictionary" does not exist | | | 42704
(1 row)
SELECT pg_input_error_message('Nonexistent', 'regnamespace');
pg_input_error_message
-------------------------------------
schema "nonexistent" does not exist
SELECT * FROM pg_input_error_info('Nonexistent', 'regnamespace');
message | detail | hint | sql_error_code
-------------------------------------+--------+------+----------------
schema "nonexistent" does not exist | | | 3F000
(1 row)
SELECT pg_input_error_message('ng_catalog.||/', 'regoper');
pg_input_error_message
-----------------------------------------
operator does not exist: ng_catalog.||/
SELECT * FROM pg_input_error_info('ng_catalog.||/', 'regoper');
message | detail | hint | sql_error_code
-----------------------------------------+--------+------+----------------
operator does not exist: ng_catalog.||/ | | | 42883
(1 row)
SELECT pg_input_error_message('-', 'regoper');
pg_input_error_message
--------------------------------
more than one operator named -
SELECT * FROM pg_input_error_info('-', 'regoper');
message | detail | hint | sql_error_code
--------------------------------+--------+------+----------------
more than one operator named - | | | 42725
(1 row)
SELECT pg_input_error_message('ng_catalog.+(int4,int4)', 'regoperator');
pg_input_error_message
--------------------------------------------------
operator does not exist: ng_catalog.+(int4,int4)
SELECT * FROM pg_input_error_info('ng_catalog.+(int4,int4)', 'regoperator');
message | detail | hint | sql_error_code
--------------------------------------------------+--------+------+----------------
operator does not exist: ng_catalog.+(int4,int4) | | | 42883
(1 row)
SELECT pg_input_error_message('-', 'regoperator');
pg_input_error_message
-----------------------------
expected a left parenthesis
SELECT * FROM pg_input_error_info('-', 'regoperator');
message | detail | hint | sql_error_code
-----------------------------+--------+------+----------------
expected a left parenthesis | | | 22P02
(1 row)
SELECT pg_input_error_message('ng_catalog.now', 'regproc');
pg_input_error_message
------------------------------------------
function "ng_catalog.now" does not exist
SELECT * FROM pg_input_error_info('ng_catalog.now', 'regproc');
message | detail | hint | sql_error_code
------------------------------------------+--------+------+----------------
function "ng_catalog.now" does not exist | | | 42883
(1 row)
SELECT pg_input_error_message('ng_catalog.abs(numeric)', 'regprocedure');
pg_input_error_message
---------------------------------------------------
function "ng_catalog.abs(numeric)" does not exist
SELECT * FROM pg_input_error_info('ng_catalog.abs(numeric)', 'regprocedure');
message | detail | hint | sql_error_code
---------------------------------------------------+--------+------+----------------
function "ng_catalog.abs(numeric)" does not exist | | | 42883
(1 row)
SELECT pg_input_error_message('ng_catalog.abs(numeric', 'regprocedure');
pg_input_error_message
------------------------------
expected a right parenthesis
SELECT * FROM pg_input_error_info('ng_catalog.abs(numeric', 'regprocedure');
message | detail | hint | sql_error_code
------------------------------+--------+------+----------------
expected a right parenthesis | | | 22P02
(1 row)
SELECT pg_input_error_message('regress_regrole_test', 'regrole');
pg_input_error_message
--------------------------------------------
role "regress_regrole_test" does not exist
SELECT * FROM pg_input_error_info('regress_regrole_test', 'regrole');
message | detail | hint | sql_error_code
--------------------------------------------+--------+------+----------------
role "regress_regrole_test" does not exist | | | 42704
(1 row)
SELECT pg_input_error_message('no_such_type', 'regtype');
pg_input_error_message
------------------------------------
type "no_such_type" does not exist
SELECT * FROM pg_input_error_info('no_such_type', 'regtype');
message | detail | hint | sql_error_code
------------------------------------+--------+------+----------------
type "no_such_type" does not exist | | | 42704
(1 row)
-- Some cases that should be soft errors, but are not yet
SELECT pg_input_error_message('incorrect type name syntax', 'regtype');
SELECT * FROM pg_input_error_info('incorrect type name syntax', 'regtype');
ERROR: syntax error at or near "type"
LINE 1: SELECT pg_input_error_message('incorrect type name syntax', ...
LINE 1: SELECT * FROM pg_input_error_info('incorrect type name synta...
^
CONTEXT: invalid type name "incorrect type name syntax"
SELECT pg_input_error_message('numeric(1,2,3)', 'regtype'); -- bogus typmod
SELECT * FROM pg_input_error_info('numeric(1,2,3)', 'regtype'); -- bogus typmod
ERROR: invalid NUMERIC type modifier
SELECT pg_input_error_message('way.too.many.names', 'regtype');
SELECT * FROM pg_input_error_info('way.too.many.names', 'regtype');
ERROR: improper qualified name (too many dotted names): way.too.many.names
SELECT pg_input_error_message('no_such_catalog.schema.name', 'regtype');
SELECT * FROM pg_input_error_info('no_such_catalog.schema.name', 'regtype');
ERROR: cross-database references are not implemented: no_such_catalog.schema.name

16
src/test/regress/expected/rowtypes.out
View File

@ -88,16 +88,16 @@ SELECT pg_input_is_valid('(1,zed)', 'complex');
f
(1 row)
SELECT pg_input_error_message('(1,zed)', 'complex');
pg_input_error_message
-------------------------------------------------------
invalid input syntax for type double precision: "zed"
SELECT * FROM pg_input_error_info('(1,zed)', 'complex');
message | detail | hint | sql_error_code
-------------------------------------------------------+--------+------+----------------
invalid input syntax for type double precision: "zed" | | | 22P02
(1 row)
SELECT pg_input_error_message('(1,1e400)', 'complex');
pg_input_error_message
---------------------------------------------------
"1e400" is out of range for type double precision
SELECT * FROM pg_input_error_info('(1,1e400)', 'complex');
message | detail | hint | sql_error_code
---------------------------------------------------+--------+------+----------------
"1e400" is out of range for type double precision | | | 22003
(1 row)
create temp table quadtable(f1 int, q quad);

24
src/test/regress/expected/strings.out
View File

@ -280,22 +280,22 @@ SELECT pg_input_is_valid(E'\\xDeAdBeE', 'bytea');
f
(1 row)
SELECT pg_input_error_message(E'\\xDeAdBeE', 'bytea');
pg_input_error_message
------------------------------------------------
invalid hexadecimal data: odd number of digits
SELECT * FROM pg_input_error_info(E'\\xDeAdBeE', 'bytea');
message | detail | hint | sql_error_code
------------------------------------------------+--------+------+----------------
invalid hexadecimal data: odd number of digits | | | 22023
(1 row)
SELECT pg_input_error_message(E'\\xDeAdBeEx', 'bytea');
pg_input_error_message
--------------------------------
invalid hexadecimal digit: "x"
SELECT * FROM pg_input_error_info(E'\\xDeAdBeEx', 'bytea');
message | detail | hint | sql_error_code
--------------------------------+--------+------+----------------
invalid hexadecimal digit: "x" | | | 22023
(1 row)
SELECT pg_input_error_message(E'foo\\99bar', 'bytea');
pg_input_error_message
-------------------------------------
invalid input syntax for type bytea
SELECT * FROM pg_input_error_info(E'foo\\99bar', 'bytea');
message | detail | hint | sql_error_code
-------------------------------------+--------+------+----------------
invalid input syntax for type bytea | | | 22P02
(1 row)
--

16
src/test/regress/expected/tid.out
View File

@ -24,10 +24,10 @@ SELECT pg_input_is_valid('(0)', 'tid');
f
(1 row)
SELECT pg_input_error_message('(0)', 'tid');
pg_input_error_message
------------------------------------------
invalid input syntax for type tid: "(0)"
SELECT * FROM pg_input_error_info('(0)', 'tid');
message | detail | hint | sql_error_code
------------------------------------------+--------+------+----------------
invalid input syntax for type tid: "(0)" | | | 22P02
(1 row)
SELECT pg_input_is_valid('(0,-1)', 'tid');
@ -36,10 +36,10 @@ SELECT pg_input_is_valid('(0,-1)', 'tid');
f
(1 row)
SELECT pg_input_error_message('(0,-1)', 'tid');
pg_input_error_message
---------------------------------------------
invalid input syntax for type tid: "(0,-1)"
SELECT * FROM pg_input_error_info('(0,-1)', 'tid');
message | detail | hint | sql_error_code
---------------------------------------------+--------+------+----------------
invalid input syntax for type tid: "(0,-1)" | | | 22P02
(1 row)
-- tests for functions related to TID handling

16
src/test/regress/expected/time.out
View File

@ -133,16 +133,16 @@ SELECT pg_input_is_valid('15:36:39 America/New_York', 'time');
f
(1 row)
SELECT pg_input_error_message('25:00:00', 'time');
pg_input_error_message
------------------------------------------------
date/time field value out of range: "25:00:00"
SELECT * FROM pg_input_error_info('25:00:00', 'time');
message | detail | hint | sql_error_code
------------------------------------------------+--------+------+----------------
date/time field value out of range: "25:00:00" | | | 22008
(1 row)
SELECT pg_input_error_message('15:36:39 America/New_York', 'time');
pg_input_error_message
-----------------------------------------------------------------
invalid input syntax for type time: "15:36:39 America/New_York"
SELECT * FROM pg_input_error_info('15:36:39 America/New_York', 'time');
message | detail | hint | sql_error_code
-----------------------------------------------------------------+--------+------+----------------
invalid input syntax for type time: "15:36:39 America/New_York" | | | 22007
(1 row)
--

16
src/test/regress/expected/timestamp.out
View File

@ -144,16 +144,16 @@ SELECT pg_input_is_valid('2001-01-01 00:00 Nehwon/Lankhmar', 'timestamp');
f
(1 row)
SELECT pg_input_error_message('garbage', 'timestamp');
pg_input_error_message
----------------------------------------------------
invalid input syntax for type timestamp: "garbage"
SELECT * FROM pg_input_error_info('garbage', 'timestamp');
message | detail | hint | sql_error_code
----------------------------------------------------+--------+------+----------------
invalid input syntax for type timestamp: "garbage" | | | 22007
(1 row)
SELECT pg_input_error_message('2001-01-01 00:00 Nehwon/Lankhmar', 'timestamp');
pg_input_error_message
--------------------------------------------
time zone "nehwon/lankhmar" not recognized
SELECT * FROM pg_input_error_info('2001-01-01 00:00 Nehwon/Lankhmar', 'timestamp');
message | detail | hint | sql_error_code
--------------------------------------------+--------+------+----------------
time zone "nehwon/lankhmar" not recognized | | | 22023
(1 row)
-- Check date conversion and date arithmetic

16
src/test/regress/expected/timestamptz.out
View File

@ -195,16 +195,16 @@ SELECT pg_input_is_valid('2001-01-01 00:00 Nehwon/Lankhmar', 'timestamptz');
f
(1 row)
SELECT pg_input_error_message('garbage', 'timestamptz');
pg_input_error_message
-------------------------------------------------------------------
invalid input syntax for type timestamp with time zone: "garbage"
SELECT * FROM pg_input_error_info('garbage', 'timestamptz');
message | detail | hint | sql_error_code
-------------------------------------------------------------------+--------+------+----------------
invalid input syntax for type timestamp with time zone: "garbage" | | | 22007
(1 row)
SELECT pg_input_error_message('2001-01-01 00:00 Nehwon/Lankhmar', 'timestamptz');
pg_input_error_message
--------------------------------------------
time zone "nehwon/lankhmar" not recognized
SELECT * FROM pg_input_error_info('2001-01-01 00:00 Nehwon/Lankhmar', 'timestamptz');
message | detail | hint | sql_error_code
--------------------------------------------+--------+------+----------------
time zone "nehwon/lankhmar" not recognized | | | 22023
(1 row)
-- Check date conversion and date arithmetic

16
src/test/regress/expected/timetz.out
View File

@ -150,16 +150,16 @@ SELECT pg_input_is_valid('15:36:39 America/New_York', 'timetz');
f
(1 row)
SELECT pg_input_error_message('25:00:00 PDT', 'timetz');
pg_input_error_message
----------------------------------------------------
date/time field value out of range: "25:00:00 PDT"
SELECT * FROM pg_input_error_info('25:00:00 PDT', 'timetz');
message | detail | hint | sql_error_code
----------------------------------------------------+--------+------+----------------
date/time field value out of range: "25:00:00 PDT" | | | 22008
(1 row)
SELECT pg_input_error_message('15:36:39 America/New_York', 'timetz');
pg_input_error_message
--------------------------------------------------------------------------------
invalid input syntax for type time with time zone: "15:36:39 America/New_York"
SELECT * FROM pg_input_error_info('15:36:39 America/New_York', 'timetz');
message | detail | hint | sql_error_code
--------------------------------------------------------------------------------+--------+------+----------------
invalid input syntax for type time with time zone: "15:36:39 America/New_York" | | | 22007
(1 row)
--

24
src/test/regress/expected/tstypes.out
View File

@ -102,10 +102,10 @@ SELECT pg_input_is_valid($$''$$, 'tsvector');
f
(1 row)
SELECT pg_input_error_message($$''$$, 'tsvector');
pg_input_error_message
--------------------------------
syntax error in tsvector: "''"
SELECT * FROM pg_input_error_info($$''$$, 'tsvector');
message | detail | hint | sql_error_code
--------------------------------+--------+------+----------------
syntax error in tsvector: "''" | | | 42601
(1 row)
--Base tsquery test
@ -404,16 +404,16 @@ SELECT pg_input_is_valid('foo!', 'tsquery');
f
(1 row)
SELECT pg_input_error_message('foo!', 'tsquery');
pg_input_error_message
---------------------------------
syntax error in tsquery: "foo!"
SELECT * FROM pg_input_error_info('foo!', 'tsquery');
message | detail | hint | sql_error_code
---------------------------------+--------+------+----------------
syntax error in tsquery: "foo!" | | | 42601
(1 row)
SELECT pg_input_error_message('a <100000> b', 'tsquery');
pg_input_error_message
---------------------------------------------------------------------------------------
distance in phrase operator must be an integer value between zero and 16384 inclusive
SELECT * FROM pg_input_error_info('a <100000> b', 'tsquery');
message | detail | hint | sql_error_code
---------------------------------------------------------------------------------------+--------+------+----------------
distance in phrase operator must be an integer value between zero and 16384 inclusive | | | 22023
(1 row)
--comparisons

8
src/test/regress/expected/uuid.out
View File

@ -46,10 +46,10 @@ SELECT pg_input_is_valid('11', 'uuid');
f
(1 row)
SELECT pg_input_error_message('11', 'uuid');
pg_input_error_message
------------------------------------------
invalid input syntax for type uuid: "11"
SELECT * FROM pg_input_error_info('11', 'uuid');
message | detail | hint | sql_error_code
------------------------------------------+--------+------+----------------
invalid input syntax for type uuid: "11" | | | 22P02
(1 row)
--inserting three input formats

8
src/test/regress/expected/varchar.out
View File

@ -124,9 +124,9 @@ SELECT pg_input_is_valid('abcde', 'varchar(4)');
f
(1 row)
SELECT pg_input_error_message('abcde', 'varchar(4)');
pg_input_error_message
----------------------------------------------
value too long for type character varying(4)
SELECT * FROM pg_input_error_info('abcde', 'varchar(4)');
message | detail | hint | sql_error_code
----------------------------------------------+--------+------+----------------
value too long for type character varying(4) | | | 22001
(1 row)

8
src/test/regress/expected/varchar_1.out
View File

@ -124,9 +124,9 @@ SELECT pg_input_is_valid('abcde', 'varchar(4)');
f
(1 row)
SELECT pg_input_error_message('abcde', 'varchar(4)');
pg_input_error_message
----------------------------------------------
value too long for type character varying(4)
SELECT * FROM pg_input_error_info('abcde', 'varchar(4)');
message | detail | hint | sql_error_code
----------------------------------------------+--------+------+----------------
value too long for type character varying(4) | | | 22001
(1 row)

8
src/test/regress/expected/varchar_2.out
View File

@ -124,9 +124,9 @@ SELECT pg_input_is_valid('abcde', 'varchar(4)');
f
(1 row)
SELECT pg_input_error_message('abcde', 'varchar(4)');
pg_input_error_message
----------------------------------------------
value too long for type character varying(4)
SELECT * FROM pg_input_error_info('abcde', 'varchar(4)');
message | detail | hint | sql_error_code
----------------------------------------------+--------+------+----------------
value too long for type character varying(4) | | | 22001
(1 row)

32
src/test/regress/expected/xid.out
View File

@ -43,10 +43,10 @@ SELECT pg_input_is_valid('asdf', 'xid');
f
(1 row)
SELECT pg_input_error_message('0xffffffffff', 'xid');
pg_input_error_message
---------------------------------------------------
value "0xffffffffff" is out of range for type xid
SELECT * FROM pg_input_error_info('0xffffffffff', 'xid');
message | detail | hint | sql_error_code
---------------------------------------------------+--------+------+----------------
value "0xffffffffff" is out of range for type xid | | | 22003
(1 row)
SELECT pg_input_is_valid('42', 'xid8');
@ -61,10 +61,10 @@ SELECT pg_input_is_valid('asdf', 'xid8');
f
(1 row)
SELECT pg_input_error_message('0xffffffffffffffffffff', 'xid8');
pg_input_error_message
--------------------------------------------------------------
value "0xffffffffffffffffffff" is out of range for type xid8
SELECT * FROM pg_input_error_info('0xffffffffffffffffffff', 'xid8');
message | detail | hint | sql_error_code
--------------------------------------------------------------+--------+------+----------------
value "0xffffffffffffffffffff" is out of range for type xid8 | | | 22003
(1 row)
-- equality
@ -223,10 +223,10 @@ select pg_input_is_valid('31:12:', 'pg_snapshot');
f
(1 row)
select pg_input_error_message('31:12:', 'pg_snapshot');
pg_input_error_message
-----------------------------------------------------
invalid input syntax for type pg_snapshot: "31:12:"
select * from pg_input_error_info('31:12:', 'pg_snapshot');
message | detail | hint | sql_error_code
-----------------------------------------------------+--------+------+----------------
invalid input syntax for type pg_snapshot: "31:12:" | | | 22P02
(1 row)
select pg_input_is_valid('12:16:14,13', 'pg_snapshot');
@ -235,10 +235,10 @@ select pg_input_is_valid('12:16:14,13', 'pg_snapshot');
f
(1 row)
select pg_input_error_message('12:16:14,13', 'pg_snapshot');
pg_input_error_message
----------------------------------------------------------
invalid input syntax for type pg_snapshot: "12:16:14,13"
select * from pg_input_error_info('12:16:14,13', 'pg_snapshot');
message | detail | hint | sql_error_code
----------------------------------------------------------+--------+------+----------------
invalid input syntax for type pg_snapshot: "12:16:14,13" | | | 22P02
(1 row)
create temp table snapshot_test (

10
src/test/regress/expected/xml.out
View File

@ -31,9 +31,9 @@ SELECT pg_input_is_valid('<value>one</', 'xml');
f
(1 row)
SELECT pg_input_error_message('<value>one</', 'xml');
pg_input_error_message
------------------------
SELECT message FROM pg_input_error_info('<value>one</', 'xml');
message
---------------------
invalid XML content
(1 row)
@ -43,8 +43,8 @@ SELECT pg_input_is_valid('<?xml version="1.0" standalone="y"?><foo/>', 'xml');
f
(1 row)
SELECT pg_input_error_message('<?xml version="1.0" standalone="y"?><foo/>', 'xml');
pg_input_error_message
SELECT message FROM pg_input_error_info('<?xml version="1.0" standalone="y"?><foo/>', 'xml');
message
----------------------------------------------
invalid XML content: invalid XML declaration
(1 row)

4
src/test/regress/expected/xml_1.out
View File

@ -29,13 +29,13 @@ DETAIL: This functionality requires the server to be built with libxml support.
SELECT pg_input_is_valid('<value>one</', 'xml');
ERROR: unsupported XML feature
DETAIL: This functionality requires the server to be built with libxml support.
SELECT pg_input_error_message('<value>one</', 'xml');
SELECT message FROM pg_input_error_info('<value>one</', 'xml');
ERROR: unsupported XML feature
DETAIL: This functionality requires the server to be built with libxml support.
SELECT pg_input_is_valid('<?xml version="1.0" standalone="y"?><foo/>', 'xml');
ERROR: unsupported XML feature
DETAIL: This functionality requires the server to be built with libxml support.
SELECT pg_input_error_message('<?xml version="1.0" standalone="y"?><foo/>', 'xml');
SELECT message FROM pg_input_error_info('<?xml version="1.0" standalone="y"?><foo/>', 'xml');
ERROR: unsupported XML feature
DETAIL: This functionality requires the server to be built with libxml support.
SELECT xmlcomment('test');

8
src/test/regress/expected/xml_2.out
View File

@ -29,8 +29,8 @@ SELECT pg_input_is_valid('<value>one</', 'xml');
f
(1 row)
SELECT pg_input_error_message('<value>one</', 'xml');
pg_input_error_message
SELECT message FROM pg_input_error_info('<value>one</', 'xml');
message
------------------------
invalid XML content
(1 row)
@ -41,8 +41,8 @@ SELECT pg_input_is_valid('<?xml version="1.0" standalone="y"?><foo/>', 'xml');
f
(1 row)
SELECT pg_input_error_message('<?xml version="1.0" standalone="y"?><foo/>', 'xml');
pg_input_error_message
SELECT message FROM pg_input_error_info('<?xml version="1.0" standalone="y"?><foo/>', 'xml');
message
----------------------------------------------
invalid XML content: invalid XML declaration
(1 row)

2
src/test/regress/sql/arrays.sql
View File

@ -117,7 +117,7 @@ SELECT a,b,c FROM arrtest;
SELECT pg_input_is_valid('{1,2,3}', 'integer[]');
SELECT pg_input_is_valid('{1,2', 'integer[]');
SELECT pg_input_is_valid('{1,zed}', 'integer[]');
SELECT pg_input_error_message('{1,zed}', 'integer[]');
SELECT * FROM pg_input_error_info('{1,zed}', 'integer[]');
-- test mixed slice/scalar subscripting
select '{{1,2,3},{4,5,6},{7,8,9}}'::int[];

10
src/test/regress/sql/bit.sql
View File

@ -232,13 +232,13 @@ TABLE bit_defaults;
-- test non-error-throwing API for some core types
SELECT pg_input_is_valid('01010001', 'bit(10)');
SELECT pg_input_error_message('01010001', 'bit(10)');
SELECT * FROM pg_input_error_info('01010001', 'bit(10)');
SELECT pg_input_is_valid('01010Z01', 'bit(8)');
SELECT pg_input_error_message('01010Z01', 'bit(8)');
SELECT * FROM pg_input_error_info('01010Z01', 'bit(8)');
SELECT pg_input_is_valid('x01010Z01', 'bit(32)');
SELECT pg_input_error_message('x01010Z01', 'bit(32)');
SELECT * FROM pg_input_error_info('x01010Z01', 'bit(32)');
SELECT pg_input_is_valid('01010Z01', 'varbit');
SELECT pg_input_error_message('01010Z01', 'varbit');
SELECT * FROM pg_input_error_info('01010Z01', 'varbit');
SELECT pg_input_is_valid('x01010Z01', 'varbit');
SELECT pg_input_error_message('x01010Z01', 'varbit');
SELECT * FROM pg_input_error_info('x01010Z01', 'varbit');

2
src/test/regress/sql/boolean.sql
View File

@ -65,7 +65,7 @@ SELECT bool '' AS error;
-- Also try it with non-error-throwing API
SELECT pg_input_is_valid('true', 'bool');
SELECT pg_input_is_valid('asdf', 'bool');
SELECT pg_input_error_message('junk', 'bool');
SELECT * FROM pg_input_error_info('junk', 'bool');
-- and, or, not in qualifications

4
src/test/regress/sql/box.sql
View File

@ -284,6 +284,6 @@ RESET enable_bitmapscan;
-- test non-error-throwing API for some core types
SELECT pg_input_is_valid('200', 'box');
SELECT pg_input_error_message('200', 'box');
SELECT * FROM pg_input_error_info('200', 'box');
SELECT pg_input_is_valid('((200,300),(500, xyz))', 'box');
SELECT pg_input_error_message('((200,300),(500, xyz))', 'box');
SELECT * FROM pg_input_error_info('((200,300),(500, xyz))', 'box');

2
src/test/regress/sql/char.sql
View File

@ -75,7 +75,7 @@ SELECT * FROM CHAR_TBL;
-- Also try it with non-error-throwing API
SELECT pg_input_is_valid('abcd ', 'char(4)');
SELECT pg_input_is_valid('abcde', 'char(4)');
SELECT pg_input_error_message('abcde', 'char(4)');
SELECT * FROM pg_input_error_info('abcde', 'char(4)');
--
-- Also test "char", which is an ad-hoc one-byte type. It can only

4
src/test/regress/sql/date.sql
View File

@ -197,8 +197,8 @@ SELECT date '5874898-01-01'; -- out of range
SELECT pg_input_is_valid('now', 'date');
SELECT pg_input_is_valid('garbage', 'date');
SELECT pg_input_is_valid('6874898-01-01', 'date');
SELECT pg_input_error_message('garbage', 'date');
SELECT pg_input_error_message('6874898-01-01', 'date');
SELECT * FROM pg_input_error_info('garbage', 'date');
SELECT * FROM pg_input_error_info('6874898-01-01', 'date');
RESET datestyle;

10
src/test/regress/sql/domain.sql
View File

@ -77,12 +77,12 @@ create domain weirdfloat float8 check((1 / value) < 10);
select pg_input_is_valid('1', 'positiveint');
select pg_input_is_valid('junk', 'positiveint');
select pg_input_is_valid('-1', 'positiveint');
select pg_input_error_message('junk', 'positiveint');
select pg_input_error_message('-1', 'positiveint');
select pg_input_error_message('junk', 'weirdfloat');
select pg_input_error_message('0.01', 'weirdfloat');
select * from pg_input_error_info('junk', 'positiveint');
select * from pg_input_error_info('-1', 'positiveint');
select * from pg_input_error_info('junk', 'weirdfloat');
select * from pg_input_error_info('0.01', 'weirdfloat');
-- We currently can't trap errors raised in the CHECK expression itself
select pg_input_error_message('0', 'weirdfloat');
select * from pg_input_error_info('0', 'weirdfloat');
drop domain positiveint;
drop domain weirdfloat;

6
src/test/regress/sql/enum.sql
View File

@ -18,8 +18,10 @@ SELECT 'mauve'::rainbow;
-- Also try it with non-error-throwing API
SELECT pg_input_is_valid('red', 'rainbow');
SELECT pg_input_is_valid('mauve', 'rainbow');
SELECT pg_input_error_message('mauve', 'rainbow');
SELECT pg_input_error_message(repeat('too_long', 32), 'rainbow');
SELECT * FROM pg_input_error_info('mauve', 'rainbow');
\x
SELECT * FROM pg_input_error_info(repeat('too_long', 32), 'rainbow');
\x
--
-- adding new values

2
src/test/regress/sql/float4.sql
View File

@ -40,7 +40,7 @@ INSERT INTO FLOAT4_TBL(f1) VALUES ('123 5');
SELECT pg_input_is_valid('34.5', 'float4');
SELECT pg_input_is_valid('xyz', 'float4');
SELECT pg_input_is_valid('1e400', 'float4');
SELECT pg_input_error_message('1e400', 'float4');
SELECT * FROM pg_input_error_info('1e400', 'float4');
-- special inputs
SELECT 'NaN'::float4;

2
src/test/regress/sql/float8.sql
View File

@ -38,7 +38,7 @@ INSERT INTO FLOAT8_TBL(f1) VALUES ('123 5');
SELECT pg_input_is_valid('34.5', 'float8');
SELECT pg_input_is_valid('xyz', 'float8');
SELECT pg_input_is_valid('1e4000', 'float8');
SELECT pg_input_error_message('1e4000', 'float8');
SELECT * FROM pg_input_error_info('1e4000', 'float8');
-- special inputs
SELECT 'NaN'::float8;

4
src/test/regress/sql/geometry.sql
View File

@ -526,6 +526,6 @@ SELECT * FROM polygon_tbl WHERE f1 @> '((1,1),(2,2),(2,1))'::polygon
-- test non-error-throwing API for some core types
SELECT pg_input_is_valid('(1', 'circle');
SELECT pg_input_error_message('1,', 'circle');
SELECT * FROM pg_input_error_info('1,', 'circle');
SELECT pg_input_is_valid('(1,2),-1', 'circle');
SELECT pg_input_error_message('(1,2),-1', 'circle');
SELECT * FROM pg_input_error_info('(1,2),-1', 'circle');

6
src/test/regress/sql/inet.sql
View File

@ -255,9 +255,9 @@ SELECT a FROM (VALUES
-- test non-error-throwing API for some core types
SELECT pg_input_is_valid('1234', 'cidr');
SELECT pg_input_error_message('1234', 'cidr');
SELECT * FROM pg_input_error_info('1234', 'cidr');
SELECT pg_input_is_valid('192.168.198.200/24', 'cidr');
SELECT pg_input_error_message('192.168.198.200/24', 'cidr');
SELECT * FROM pg_input_error_info('192.168.198.200/24', 'cidr');
SELECT pg_input_is_valid('1234', 'inet');
SELECT pg_input_error_message('1234', 'inet');
SELECT * FROM pg_input_error_info('1234', 'inet');

6
src/test/regress/sql/int2.sql
View File

@ -21,12 +21,12 @@ SELECT * FROM INT2_TBL;
SELECT pg_input_is_valid('34', 'int2');
SELECT pg_input_is_valid('asdf', 'int2');
SELECT pg_input_is_valid('50000', 'int2');
SELECT pg_input_error_message('50000', 'int2');
SELECT * FROM pg_input_error_info('50000', 'int2');
-- While we're here, check int2vector as well
SELECT pg_input_is_valid(' 1 3 5 ', 'int2vector');
SELECT pg_input_error_message('1 asdf', 'int2vector');
SELECT pg_input_error_message('50000', 'int2vector');
SELECT * FROM pg_input_error_info('1 asdf', 'int2vector');
SELECT * FROM pg_input_error_info('50000', 'int2vector');
SELECT * FROM INT2_TBL AS f(a, b);

2
src/test/regress/sql/int4.sql
View File

@ -21,7 +21,7 @@ SELECT * FROM INT4_TBL;
SELECT pg_input_is_valid('34', 'int4');
SELECT pg_input_is_valid('asdf', 'int4');
SELECT pg_input_is_valid('1000000000000', 'int4');
SELECT pg_input_error_message('1000000000000', 'int4');
SELECT * FROM pg_input_error_info('1000000000000', 'int4');
SELECT i.* FROM INT4_TBL i WHERE i.f1 <> int2 '0';

2
src/test/regress/sql/int8.sql
View File

@ -20,7 +20,7 @@ SELECT * FROM INT8_TBL;
SELECT pg_input_is_valid('34', 'int8');
SELECT pg_input_is_valid('asdf', 'int8');
SELECT pg_input_is_valid('10000000000000000000', 'int8');
SELECT pg_input_error_message('10000000000000000000', 'int8');
SELECT * FROM pg_input_error_info('10000000000000000000', 'int8');
-- int8/int8 cmp
SELECT * FROM INT8_TBL WHERE q2 = 4567890123456789;

4
src/test/regress/sql/interval.sql
View File

@ -36,8 +36,8 @@ INSERT INTO INTERVAL_TBL (f1) VALUES ('@ 30 eons ago');
SELECT pg_input_is_valid('1.5 weeks', 'interval');
SELECT pg_input_is_valid('garbage', 'interval');
SELECT pg_input_is_valid('@ 30 eons ago', 'interval');
SELECT pg_input_error_message('garbage', 'interval');
SELECT pg_input_error_message('@ 30 eons ago', 'interval');
SELECT * FROM pg_input_error_info('garbage', 'interval');
SELECT * FROM pg_input_error_info('@ 30 eons ago', 'interval');
-- test interval operators

2
src/test/regress/sql/json.sql
View File

@ -84,7 +84,7 @@ SELECT '{
-- test non-error-throwing input
select pg_input_is_valid('{"a":true}', 'json');
select pg_input_is_valid('{"a":true', 'json');
select pg_input_error_message('{"a":true', 'json');
select * from pg_input_error_info('{"a":true', 'json');
--constructors
-- array_to_json

2
src/test/regress/sql/json_encoding.sql
View File

@ -79,4 +79,4 @@ SELECT jsonb '{ "a": "null \\u0000 escape" }' ->> 'a' as not_an_escape;
-- soft error for input-time failure
select pg_input_error_message('{ "a": "\ud83d\ude04\ud83d\udc36" }', 'jsonb');
select * from pg_input_error_info('{ "a": "\ud83d\ude04\ud83d\udc36" }', 'jsonb');

4
src/test/regress/sql/jsonb.sql
View File

@ -89,8 +89,8 @@ SELECT '{
-- test non-error-throwing input
select pg_input_is_valid('{"a":true}', 'jsonb');
select pg_input_is_valid('{"a":true', 'jsonb');
select pg_input_error_message('{"a":true', 'jsonb');
select pg_input_error_message('{"a":1e1000000}', 'jsonb');
select * from pg_input_error_info('{"a":true', 'jsonb');
select * from pg_input_error_info('{"a":1e1000000}', 'jsonb');
-- make sure jsonb is passed through json generators without being escaped
SELECT array_to_json(ARRAY [jsonb '{"a":1}', jsonb '{"b":[2,3]}']);

8
src/test/regress/sql/jsonpath.sql
View File

@ -192,9 +192,13 @@ select '1?(2>3)'::jsonpath;
SELECT str as jsonpath,
pg_input_is_valid(str,'jsonpath') as ok,
pg_input_error_message(str,'jsonpath') as errmsg
errinfo.sql_error_code,
errinfo.message,
errinfo.detail,
errinfo.hint
FROM unnest(ARRAY['$ ? (@ like_regex "pattern" flag "smixq")'::text,
'$ ? (@ like_regex "pattern" flag "a")',
'@ + 1',
'00',
'1a']) str;
'1a']) str,
LATERAL pg_input_error_info(str, 'jsonpath') as errinfo;

10
src/test/regress/sql/line.sql
View File

@ -43,12 +43,12 @@ select '{nan, 1, nan}'::line = '{nan, 1, nan}'::line as true,
-- test non-error-throwing API for some core types
SELECT pg_input_is_valid('{1, 1}', 'line');
SELECT pg_input_error_message('{1, 1}', 'line');
SELECT * FROM pg_input_error_info('{1, 1}', 'line');
SELECT pg_input_is_valid('{0, 0, 0}', 'line');
SELECT pg_input_error_message('{0, 0, 0}', 'line');
SELECT * FROM pg_input_error_info('{0, 0, 0}', 'line');
SELECT pg_input_is_valid('{1, 1, a}', 'line');
SELECT pg_input_error_message('{1, 1, a}', 'line');
SELECT * FROM pg_input_error_info('{1, 1, a}', 'line');
SELECT pg_input_is_valid('{1, 1, 1e400}', 'line');
SELECT pg_input_error_message('{1, 1, 1e400}', 'line');
SELECT * FROM pg_input_error_info('{1, 1, 1e400}', 'line');
SELECT pg_input_is_valid('(1, 1), (1, 1e400)', 'line');
SELECT pg_input_error_message('(1, 1), (1, 1e400)', 'line');
SELECT * FROM pg_input_error_info('(1, 1), (1, 1e400)', 'line');

2
src/test/regress/sql/lseg.sql
View File

@ -25,4 +25,4 @@ select * from LSEG_TBL;
-- test non-error-throwing API for some core types
SELECT pg_input_is_valid('[(1,2),(3)]', 'lseg');
SELECT pg_input_error_message('[(1,2),(3)]', 'lseg');
SELECT * FROM pg_input_error_info('[(1,2),(3)]', 'lseg');

4
src/test/regress/sql/macaddr.sql
View File

@ -44,6 +44,6 @@ DROP TABLE macaddr_data;
-- test non-error-throwing API for some core types
SELECT pg_input_is_valid('08:00:2b:01:02:ZZ', 'macaddr');
SELECT pg_input_error_message('08:00:2b:01:02:ZZ', 'macaddr');
SELECT * FROM pg_input_error_info('08:00:2b:01:02:ZZ', 'macaddr');
SELECT pg_input_is_valid('08:00:2b:01:02:', 'macaddr');
SELECT pg_input_error_message('08:00:2b:01:02:', 'macaddr');
SELECT * FROM pg_input_error_info('08:00:2b:01:02:', 'macaddr');

4
src/test/regress/sql/macaddr8.sql
View File

@ -90,6 +90,6 @@ DROP TABLE macaddr8_data;
-- test non-error-throwing API for some core types
SELECT pg_input_is_valid('08:00:2b:01:02:03:04:ZZ', 'macaddr8');
SELECT pg_input_error_message('08:00:2b:01:02:03:04:ZZ', 'macaddr8');
SELECT * FROM pg_input_error_info('08:00:2b:01:02:03:04:ZZ', 'macaddr8');
SELECT pg_input_is_valid('08:00:2b:01:02:03:04:', 'macaddr8');
SELECT pg_input_error_message('08:00:2b:01:02:03:04:', 'macaddr8');
SELECT * FROM pg_input_error_info('08:00:2b:01:02:03:04:', 'macaddr8');

4
src/test/regress/sql/money.sql
View File

@ -90,9 +90,9 @@ SELECT '($123,456.78)'::money;
-- test non-error-throwing API
SELECT pg_input_is_valid('\x0001', 'money');
SELECT pg_input_error_message('\x0001', 'money');
SELECT * FROM pg_input_error_info('\x0001', 'money');
SELECT pg_input_is_valid('192233720368547758.07', 'money');
SELECT pg_input_error_message('192233720368547758.07', 'money');
SELECT * FROM pg_input_error_info('192233720368547758.07', 'money');
-- documented minimums and maximums
SELECT '-92233720368547758.08'::money;

4
src/test/regress/sql/multirangetypes.sql
View File

@ -61,9 +61,9 @@ select '{(a,a)}'::textmultirange;
-- Also try it with non-error-throwing API
select pg_input_is_valid('{[1,2], [4,5]}', 'int4multirange');
select pg_input_is_valid('{[1,2], [4,5]', 'int4multirange');
select pg_input_error_message('{[1,2], [4,5]', 'int4multirange');
select * from pg_input_error_info('{[1,2], [4,5]', 'int4multirange');
select pg_input_is_valid('{[1,2], [4,zed]}', 'int4multirange');
select pg_input_error_message('{[1,2], [4,zed]}', 'int4multirange');
select * from pg_input_error_info('{[1,2], [4,zed]}', 'int4multirange');
--
-- test the constructor

6
src/test/regress/sql/numeric.sql
View File

@ -1086,11 +1086,11 @@ SELECT * FROM num_input_test;
SELECT pg_input_is_valid('34.5', 'numeric');
SELECT pg_input_is_valid('34xyz', 'numeric');
SELECT pg_input_is_valid('1e400000', 'numeric');
SELECT pg_input_error_message('1e400000', 'numeric');
SELECT * FROM pg_input_error_info('1e400000', 'numeric');
SELECT pg_input_is_valid('1234.567', 'numeric(8,4)');
SELECT pg_input_is_valid('1234.567', 'numeric(7,4)');
SELECT pg_input_error_message('1234.567', 'numeric(7,4)');
SELECT pg_input_error_message('0x1234.567', 'numeric');
SELECT * FROM pg_input_error_info('1234.567', 'numeric(7,4)');
SELECT * FROM pg_input_error_info('0x1234.567', 'numeric');
--
-- Test precision and scale typemods

8
src/test/regress/sql/oid.sql
View File

@ -31,16 +31,16 @@ SELECT * FROM OID_TBL;
-- Also try it with non-error-throwing API
SELECT pg_input_is_valid('1234', 'oid');
SELECT pg_input_is_valid('01XYZ', 'oid');
SELECT pg_input_error_message('01XYZ', 'oid');
SELECT * FROM pg_input_error_info('01XYZ', 'oid');
SELECT pg_input_is_valid('9999999999', 'oid');
SELECT pg_input_error_message('9999999999', 'oid');
SELECT * FROM pg_input_error_info('9999999999', 'oid');
-- While we're here, check oidvector as well
SELECT pg_input_is_valid(' 1 2 4 ', 'oidvector');
SELECT pg_input_is_valid('01 01XYZ', 'oidvector');
SELECT pg_input_error_message('01 01XYZ', 'oidvector');
SELECT * FROM pg_input_error_info('01 01XYZ', 'oidvector');
SELECT pg_input_is_valid('01 9999999999', 'oidvector');
SELECT pg_input_error_message('01 9999999999', 'oidvector');
SELECT * FROM pg_input_error_info('01 9999999999', 'oidvector');
SELECT o.* FROM OID_TBL o WHERE o.f1 = 1234;

4
src/test/regress/sql/path.sql
View File

@ -45,6 +45,6 @@ SELECT popen(f1) AS open_path FROM PATH_TBL;
-- test non-error-throwing API for some core types
SELECT pg_input_is_valid('[(1,2),(3)]', 'path');
SELECT pg_input_error_message('[(1,2),(3)]', 'path');
SELECT * FROM pg_input_error_info('[(1,2),(3)]', 'path');
SELECT pg_input_is_valid('[(1,2,6),(3,4,6)]', 'path');
SELECT pg_input_error_message('[(1,2,6),(3,4,6)]', 'path');
SELECT * FROM pg_input_error_info('[(1,2,6),(3,4,6)]', 'path');

2
src/test/regress/sql/pg_lsn.sql
View File

@ -17,7 +17,7 @@ INSERT INTO PG_LSN_TBL VALUES ('/ABCD');
-- Also try it with non-error-throwing API
SELECT pg_input_is_valid('16AE7F7', 'pg_lsn');
SELECT pg_input_error_message('16AE7F7', 'pg_lsn');
SELECT * FROM pg_input_error_info('16AE7F7', 'pg_lsn');
-- Min/Max aggregation
SELECT MIN(f1), MAX(f1) FROM PG_LSN_TBL;

Some files were not shown because too many files have changed in this diff Show More