parse
SELECT
----
SELECT  -- normalized!
SELECT  -- fully parenthesized
SELECT  -- literals removed
SELECT  -- identifiers removed

parse
SELECT 1 + 1
----
SELECT 1 + 1
SELECT ((1) + (1)) -- fully parenthesized
SELECT _ + _ -- literals removed
SELECT 1 + 1 -- identifiers removed

parse
SELECT +1
----
SELECT 1 -- normalized!
SELECT (1) -- fully parenthesized
SELECT _ -- literals removed
SELECT 1 -- identifiers removed

parse
SELECT - - 5
----
SELECT 5 -- normalized!
SELECT (5) -- fully parenthesized
SELECT _ -- literals removed
SELECT 5 -- identifiers removed

parse
SELECT - + 5
----
SELECT -5 -- normalized!
SELECT (-5) -- fully parenthesized
SELECT _ -- literals removed
SELECT -5 -- identifiers removed

parse
SELECT -1
----
SELECT -1
SELECT (-1) -- fully parenthesized
SELECT _ -- literals removed
SELECT -1 -- identifiers removed

parse
SELECT .1
----
SELECT .1
SELECT (.1) -- fully parenthesized
SELECT _ -- literals removed
SELECT .1 -- identifiers removed

parse
SELECT 1.2e1
----
SELECT 1.2e1
SELECT (1.2e1) -- fully parenthesized
SELECT _ -- literals removed
SELECT 1.2e1 -- identifiers removed

parse
SELECT 1.2e+1
----
SELECT 1.2e+1
SELECT (1.2e+1) -- fully parenthesized
SELECT _ -- literals removed
SELECT 1.2e+1 -- identifiers removed

parse
SELECT 1.2e-1
----
SELECT 1.2e-1
SELECT (1.2e-1) -- fully parenthesized
SELECT _ -- literals removed
SELECT 1.2e-1 -- identifiers removed

error
SELECT 1e-\n-1
----
lexical error: invalid floating point literal
DETAIL: source SQL:
SELECT 1e-\n-1
       ^

parse
SELECT *,-/* comment */-5
----
SELECT *, 5 -- normalized!
SELECT (*), (5) -- fully parenthesized
SELECT *, _ -- literals removed
SELECT *, 5 -- identifiers removed

parse
SELECT -
-5
----
SELECT 5 -- normalized!
SELECT (5) -- fully parenthesized
SELECT _ -- literals removed
SELECT 5 -- identifiers removed

parse
SELECT -0.-/*test*/-1
----
SELECT -0. - -1 -- normalized!
SELECT ((-0.) - (-1)) -- fully parenthesized
SELECT _ - _ -- literals removed
SELECT -0. - -1 -- identifiers removed

parse
SELECT~~+~++~bd(*)
----
SELECT ~(~(~(~bd(*)))) -- normalized!
SELECT (~((~((~((~(bd((*)))))))))) -- fully parenthesized
SELECT ~(~(~(~bd(*)))) -- literals removed
SELECT ~(~(~(~_(*)))) -- identifiers removed

parse
SELECT true AND false
----
SELECT true AND false
SELECT ((true) AND (false)) -- fully parenthesized
SELECT _ AND _ -- literals removed
SELECT true AND false -- identifiers removed

parse
SELECT true AND NULL
----
SELECT true AND NULL
SELECT ((true) AND (NULL)) -- fully parenthesized
SELECT _ AND _ -- literals removed
SELECT true AND NULL -- identifiers removed

parse
SELECT true = false
----
SELECT true = false
SELECT ((true) = (false)) -- fully parenthesized
SELECT _ = _ -- literals removed
SELECT true = false -- identifiers removed

parse
SELECT (true = false)
----
SELECT (true = false)
SELECT ((((true) = (false)))) -- fully parenthesized
SELECT (_ = _) -- literals removed
SELECT (true = false) -- identifiers removed

parse
SELECT (ARRAY['a', 'b'])[2]
----
SELECT (ARRAY['a', 'b'])[2]
SELECT ((((ARRAY[('a'), ('b')])))[(2)]) -- fully parenthesized
SELECT (ARRAY['_', '_'])[_] -- literals removed
SELECT (ARRAY['a', 'b'])[2] -- identifiers removed

parse
SELECT (ARRAY (VALUES (1), (2)))[1]
----
SELECT (ARRAY (VALUES (1), (2)))[1]
SELECT ((((ARRAY ((VALUES ((1)), ((2)))))))[(1)]) -- fully parenthesized
SELECT (ARRAY (VALUES (_), (__more1_10__)))[_] -- literals removed
SELECT (ARRAY (VALUES (1), (2)))[1] -- identifiers removed

parse
SELECT+y[array[]]
----
SELECT y[ARRAY[]] -- normalized!
SELECT ((y)[(ARRAY[])]) -- fully parenthesized
SELECT y[ARRAY[]] -- literals removed
SELECT _[ARRAY[]] -- identifiers removed

parse
SELECT (ARRAY (1, 2))[1]
----
SELECT (ARRAY[1, 2])[1] -- normalized!
SELECT ((((ARRAY[(1), (2)])))[(1)]) -- fully parenthesized
SELECT (ARRAY[_, _])[_] -- literals removed
SELECT (ARRAY[1, 2])[1] -- identifiers removed

error
SELECT ARRAY[]::unknown[]
----
at or near "EOF": syntax error: type unknown[] does not exist
DETAIL: source SQL:
SELECT ARRAY[]::unknown[]
                         ^

error
SELECT CASE 1 = 1 WHEN true THEN ARRAY[1, 2] ELSE ARRAY[2, 3] END[1]
----
at or near "[": syntax error
DETAIL: source SQL:
SELECT CASE 1 = 1 WHEN true THEN ARRAY[1, 2] ELSE ARRAY[2, 3] END[1]
                                                                 ^

parse
SELECT FAMILY (x)
----
SELECT family(x) -- normalized!
SELECT (family((x))) -- fully parenthesized
SELECT family(x) -- literals removed
SELECT _(_) -- identifiers removed

parse
SELECT 1 IN (b)
----
SELECT 1 IN (b,) -- normalized!
SELECT ((1) IN (((b),))) -- fully parenthesized
SELECT _ IN (b,) -- literals removed
SELECT 1 IN (_,) -- identifiers removed

parse
SELECT ROW()
----
SELECT () -- normalized!
SELECT (()) -- fully parenthesized
SELECT () -- literals removed
SELECT () -- identifiers removed

parse
SELECT ROW(1)
----
SELECT (1,) -- normalized!
SELECT (((1),)) -- fully parenthesized
SELECT (_,) -- literals removed
SELECT (1,) -- identifiers removed

parse
SELECT (ROW(1) AS a)
----
SELECT ((1,) AS a) -- normalized!
SELECT ((((1),) AS a)) -- fully parenthesized
SELECT ((_,) AS a) -- literals removed
SELECT ((1,) AS _) -- identifiers removed

parse
SELECT (ROW(1) AS a, b)
----
SELECT ((1,) AS a, b) -- normalized!
SELECT ((((1),) AS a, b)) -- fully parenthesized
SELECT ((_,) AS a, b) -- literals removed
SELECT ((1,) AS _, _) -- identifiers removed

parse
SELECT (SELECT 1)
----
SELECT (SELECT 1)
SELECT ((SELECT (1))) -- fully parenthesized
SELECT (SELECT _) -- literals removed
SELECT (SELECT 1) -- identifiers removed

parse
SELECT ((SELECT 1))
----
SELECT ((SELECT 1))
SELECT (((SELECT (1)))) -- fully parenthesized
SELECT ((SELECT _)) -- literals removed
SELECT ((SELECT 1)) -- identifiers removed

parse
SELECT (SELECT ARRAY['a', 'b'])[2]
----
SELECT (SELECT ARRAY['a', 'b'])[2]
SELECT (((SELECT (ARRAY[('a'), ('b')])))[(2)]) -- fully parenthesized
SELECT (SELECT ARRAY['_', '_'])[_] -- literals removed
SELECT (SELECT ARRAY['a', 'b'])[2] -- identifiers removed

parse
SELECT ((SELECT ARRAY['a', 'b']))[2]
----
SELECT ((SELECT ARRAY['a', 'b']))[2]
SELECT ((((SELECT (ARRAY[('a'), ('b')]))))[(2)]) -- fully parenthesized
SELECT ((SELECT ARRAY['_', '_']))[_] -- literals removed
SELECT ((SELECT ARRAY['a', 'b']))[2] -- identifiers removed

parse
SELECT ((((VALUES (1)))))
----
SELECT ((((VALUES (1)))))
SELECT (((((VALUES ((1))))))) -- fully parenthesized
SELECT ((((VALUES (_))))) -- literals removed
SELECT ((((VALUES (1))))) -- identifiers removed

parse
SELECT EXISTS (SELECT 1)
----
SELECT EXISTS (SELECT 1)
SELECT (EXISTS (SELECT (1))) -- fully parenthesized
SELECT EXISTS (SELECT _) -- literals removed
SELECT EXISTS (SELECT 1) -- identifiers removed

error
SELECT EXISTS(SELECT 1)[1]
----
at or near "[": syntax error
DETAIL: source SQL:
SELECT EXISTS(SELECT 1)[1]
                       ^

parse
SELECT (VALUES (1))
----
SELECT (VALUES (1))
SELECT ((VALUES ((1)))) -- fully parenthesized
SELECT (VALUES (_)) -- literals removed
SELECT (VALUES (1)) -- identifiers removed

parse
SELECT (1, 2, 3)
----
SELECT (1, 2, 3)
SELECT (((1), (2), (3))) -- fully parenthesized
SELECT (_, _, __more1_10__) -- literals removed
SELECT (1, 2, 3) -- identifiers removed

parse
SELECT ((1, 2, 3) AS a, b, c)
----
SELECT ((1, 2, 3) AS a, b, c)
SELECT ((((1), (2), (3)) AS a, b, c)) -- fully parenthesized
SELECT ((_, _, __more1_10__) AS a, b) -- literals removed
SELECT ((1, 2, 3) AS _, _, _) -- identifiers removed

parse
SELECT ((1, 2, 3) AS a)
----
SELECT ((1, 2, 3) AS a)
SELECT ((((1), (2), (3)) AS a)) -- fully parenthesized
SELECT ((_, _, __more1_10__) AS a) -- literals removed
SELECT ((1, 2, 3) AS _) -- identifiers removed

parse
SELECT ((1, 2, 3) AS a, b)
----
SELECT ((1, 2, 3) AS a, b)
SELECT ((((1), (2), (3)) AS a, b)) -- fully parenthesized
SELECT ((_, _, __more1_10__) AS a, b) -- literals removed
SELECT ((1, 2, 3) AS _, _) -- identifiers removed

parse
SELECT ((1, 2) AS a, b, c)
----
SELECT ((1, 2) AS a, b, c)
SELECT ((((1), (2)) AS a, b, c)) -- fully parenthesized
SELECT ((_, _) AS a, b, c) -- literals removed
SELECT ((1, 2) AS _, _, _) -- identifiers removed

parse
SELECT ((1, 2, 3) AS a, b, c, d)
----
SELECT ((1, 2, 3) AS a, b, c, d)
SELECT ((((1), (2), (3)) AS a, b, c, d)) -- fully parenthesized
SELECT ((_, _, __more1_10__) AS a, b) -- literals removed
SELECT ((1, 2, 3) AS _, _, _, _) -- identifiers removed

parse
SELECT ((1, 2, 3))
----
SELECT ((1, 2, 3))
SELECT (((((1), (2), (3))))) -- fully parenthesized
SELECT ((_, _, __more1_10__)) -- literals removed
SELECT ((1, 2, 3)) -- identifiers removed

parse
SELECT ((1, 2, 3) AS a, b, c)
----
SELECT ((1, 2, 3) AS a, b, c)
SELECT ((((1), (2), (3)) AS a, b, c)) -- fully parenthesized
SELECT ((_, _, __more1_10__) AS a, b) -- literals removed
SELECT ((1, 2, 3) AS _, _, _) -- identifiers removed

parse
SELECT (((1, 2, 3) AS a, b, c)).a
----
SELECT (((1, 2, 3) AS a, b, c)).a
SELECT ((((((1), (2), (3)) AS a, b, c))).a) -- fully parenthesized
SELECT (((_, _, __more1_10__) AS a, b)).a -- literals removed
SELECT (((1, 2, 3) AS _, _, _))._ -- identifiers removed

parse
SELECT (((1, 2, 3) AS a, b, c)).*
----
SELECT (((1, 2, 3) AS a, b, c)).*
SELECT ((((((1), (2), (3)) AS a, b, c))).*) -- fully parenthesized
SELECT (((_, _, __more1_10__) AS a, b)).* -- literals removed
SELECT (((1, 2, 3) AS _, _, _)).* -- identifiers removed

parse
SELECT ()
----
SELECT ()
SELECT (()) -- fully parenthesized
SELECT () -- literals removed
SELECT () -- identifiers removed

parse
SELECT (() AS a)
----
SELECT (() AS a)
SELECT ((() AS a)) -- fully parenthesized
SELECT (() AS a) -- literals removed
SELECT (() AS _) -- identifiers removed

parse
SELECT ((() AS a)).a
----
SELECT ((() AS a)).a
SELECT ((((() AS a))).a) -- fully parenthesized
SELECT ((() AS a)).a -- literals removed
SELECT ((() AS _))._ -- identifiers removed

parse
SELECT ((() AS a)).*
----
SELECT ((() AS a)).*
SELECT ((((() AS a))).*) -- fully parenthesized
SELECT ((() AS a)).* -- literals removed
SELECT ((() AS _)).* -- identifiers removed

parse
SELECT ((() AS a)).@1
----
SELECT ((() AS a)).@1
SELECT ((((() AS a))).@1) -- fully parenthesized
SELECT ((() AS a)).@1 -- literals removed
SELECT ((() AS _)).@1 -- identifiers removed

parse
SELECT (TABLE a)
----
SELECT (TABLE a)
SELECT ((TABLE a)) -- fully parenthesized
SELECT (TABLE a) -- literals removed
SELECT (TABLE _) -- identifiers removed

parse
SELECT 0x1
----
SELECT 0x1
SELECT (0x1) -- fully parenthesized
SELECT _ -- literals removed
SELECT 0x1 -- identifiers removed

parse
SELECT 'a''a'
----
SELECT e'a\'a' -- normalized!
SELECT (e'a\'a') -- fully parenthesized
SELECT '_' -- literals removed
SELECT e'a\'a' -- identifiers removed

parse
SELECT 'a\a'
----
SELECT e'a\\a' -- normalized!
SELECT (e'a\\a') -- fully parenthesized
SELECT '_' -- literals removed
SELECT e'a\\a' -- identifiers removed

parse
SELECT 'a\n'
----
SELECT e'a\\n' -- normalized!
SELECT (e'a\\n') -- fully parenthesized
SELECT '_' -- literals removed
SELECT e'a\\n' -- identifiers removed

parse
SELECT '
'
----
SELECT e'\n' -- normalized!
SELECT (e'\n') -- fully parenthesized
SELECT '_' -- literals removed
SELECT e'\n' -- identifiers removed

parse
SELECT '
\'
----
SELECT e'\n\\' -- normalized!
SELECT (e'\n\\') -- fully parenthesized
SELECT '_' -- literals removed
SELECT e'\n\\' -- identifiers removed

parse
SELECT 'a'
'b'
----
SELECT 'ab' -- normalized!
SELECT ('ab') -- fully parenthesized
SELECT '_' -- literals removed
SELECT 'ab' -- identifiers removed

parse
SELECT 'a'


'b'
----
SELECT 'ab' -- normalized!
SELECT ('ab') -- fully parenthesized
SELECT '_' -- literals removed
SELECT 'ab' -- identifiers removed

parse
SELECT x'61'
----
SELECT b'a' -- normalized!
SELECT (b'a') -- fully parenthesized
SELECT '_' -- literals removed
SELECT b'a' -- identifiers removed

parse
SELECT X'61'
----
SELECT b'a' -- normalized!
SELECT (b'a') -- fully parenthesized
SELECT '_' -- literals removed
SELECT b'a' -- identifiers removed


parse
SELECT 'Deutsch' COLLATE de
----
SELECT 'Deutsch' COLLATE de
SELECT (('Deutsch') COLLATE de) -- fully parenthesized
SELECT '_' COLLATE de -- literals removed
SELECT 'Deutsch' COLLATE de -- identifiers removed

parse
SELECT a @> b
----
SELECT a @> b
SELECT ((a) @> (b)) -- fully parenthesized
SELECT a @> b -- literals removed
SELECT _ @> _ -- identifiers removed

parse
SELECT a <@ b
----
SELECT a <@ b
SELECT ((a) <@ (b)) -- fully parenthesized
SELECT a <@ b -- literals removed
SELECT _ <@ _ -- identifiers removed

parse
SELECT a ? b
----
SELECT a ? b
SELECT ((a) ? (b)) -- fully parenthesized
SELECT a ? b -- literals removed
SELECT _ ? _ -- identifiers removed

parse
SELECT a ?| b
----
SELECT a ?| b
SELECT ((a) ?| (b)) -- fully parenthesized
SELECT a ?| b -- literals removed
SELECT _ ?| _ -- identifiers removed

parse
SELECT a ?& b
----
SELECT a ?& b
SELECT ((a) ?& (b)) -- fully parenthesized
SELECT a ?& b -- literals removed
SELECT _ ?& _ -- identifiers removed

## The following JSON expressions
## do not anonymize properly, see
## issue https://github.com/cockroachdb/cockroach/issues/60673

parse
SELECT a->'x'
----
SELECT a->'x'
SELECT ((a)->('x')) -- fully parenthesized
SELECT a->'_' -- literals removed
SELECT _->'x' -- identifiers removed

parse
SELECT a#>'{x}'
----
SELECT a#>'{x}'
SELECT ((a)#>('{x}')) -- fully parenthesized
SELECT a#>'_' -- literals removed
SELECT _#>'{x}' -- identifiers removed

parse
SELECT a#>>'{x}'
----
SELECT a#>>'{x}'
SELECT ((a)#>>('{x}')) -- fully parenthesized
SELECT a#>>'_' -- literals removed
SELECT _#>>'{x}' -- identifiers removed

parse
SELECT (a->'x')->'y'
----
SELECT (a->'x')->'y'
SELECT (((((a)->('x'))))->('y')) -- fully parenthesized
SELECT (a->'_')->'_' -- literals removed
SELECT (_->'x')->'y' -- identifiers removed

parse
SELECT (a->'x')->>'y'
----
SELECT (a->'x')->>'y'
SELECT (((((a)->('x'))))->>('y')) -- fully parenthesized
SELECT (a->'_')->>'_' -- literals removed
SELECT (_->'x')->>'y' -- identifiers removed

parse
SELECT a #- '{x}'
----
SELECT json_remove_path(a, '{x}') -- normalized!
SELECT (json_remove_path((a), ('{x}'))) -- fully parenthesized
SELECT json_remove_path(a, '_') -- literals removed
SELECT json_remove_path(_, '{x}') -- identifiers removed


parse
SELECT b && c
----
SELECT b && c
SELECT ((b) && (c)) -- fully parenthesized
SELECT b && c -- literals removed
SELECT _ && _ -- identifiers removed

parse
SELECT |/a
----
SELECT |/a
SELECT (|/(a)) -- fully parenthesized
SELECT |/a -- literals removed
SELECT |/_ -- identifiers removed

parse
SELECT ||/a
----
SELECT ||/a
SELECT (||/(a)) -- fully parenthesized
SELECT ||/a -- literals removed
SELECT ||/_ -- identifiers removed

error
SELECT 1 ||/ 5
----
at or near "5": syntax error
DETAIL: source SQL:
SELECT 1 ||/ 5
             ^


parse
SELECT BOOL 'foo', 'foo'::BOOL
----
SELECT BOOL 'foo', 'foo'::BOOL
SELECT (BOOL ('foo')), (('foo')::BOOL) -- fully parenthesized
SELECT BOOL '_', '_'::BOOL -- literals removed
SELECT BOOL 'foo', 'foo'::BOOL -- identifiers removed

parse
SELECT BIT '10', '10'::BIT, BIT(2) '10'
----
SELECT BIT '10', '10'::BIT, BIT(2) '10'
SELECT (BIT ('10')), (('10')::BIT), (BIT(2) ('10')) -- fully parenthesized
SELECT BIT '_', '_'::BIT, BIT(2) '_' -- literals removed
SELECT BIT '10', '10'::BIT, BIT(2) '10' -- identifiers removed

parse
SELECT VARBIT '1', '1'::VARBIT, VARBIT(2) '01'
----
SELECT VARBIT '1', '1'::VARBIT, VARBIT(2) '01'
SELECT (VARBIT ('1')), (('1')::VARBIT), (VARBIT(2) ('01')) -- fully parenthesized
SELECT VARBIT '_', '_'::VARBIT, VARBIT(2) '_' -- literals removed
SELECT VARBIT '1', '1'::VARBIT, VARBIT(2) '01' -- identifiers removed

parse
SELECT INT2 'foo', 'foo'::INT2
----
SELECT INT2 'foo', 'foo'::INT2
SELECT (INT2 ('foo')), (('foo')::INT2) -- fully parenthesized
SELECT INT2 '_', '_'::INT2 -- literals removed
SELECT INT2 'foo', 'foo'::INT2 -- identifiers removed

parse
SELECT INT4 'foo', 'foo'::INT4
----
SELECT INT4 'foo', 'foo'::INT4
SELECT (INT4 ('foo')), (('foo')::INT4) -- fully parenthesized
SELECT INT4 '_', '_'::INT4 -- literals removed
SELECT INT4 'foo', 'foo'::INT4 -- identifiers removed

parse
SELECT INT8 'foo', 'foo'::INT8
----
SELECT INT8 'foo', 'foo'::INT8
SELECT (INT8 ('foo')), (('foo')::INT8) -- fully parenthesized
SELECT INT8 '_', '_'::INT8 -- literals removed
SELECT INT8 'foo', 'foo'::INT8 -- identifiers removed

parse
SELECT FLOAT4 'foo', 'foo'::FLOAT4
----
SELECT FLOAT4 'foo', 'foo'::FLOAT4
SELECT (FLOAT4 ('foo')), (('foo')::FLOAT4) -- fully parenthesized
SELECT FLOAT4 '_', '_'::FLOAT4 -- literals removed
SELECT FLOAT4 'foo', 'foo'::FLOAT4 -- identifiers removed

parse
SELECT REAL 'foo'
----
SELECT FLOAT4 'foo' -- normalized!
SELECT (FLOAT4 ('foo')) -- fully parenthesized
SELECT FLOAT4 '_' -- literals removed
SELECT FLOAT4 'foo' -- identifiers removed

parse
SELECT DOUBLE PRECISION 'foo'
----
SELECT FLOAT8 'foo' -- normalized!
SELECT (FLOAT8 ('foo')) -- fully parenthesized
SELECT FLOAT8 '_' -- literals removed
SELECT FLOAT8 'foo' -- identifiers removed


parse
SELECT DECIMAL 'foo', 'foo'::DECIMAL
----
SELECT DECIMAL 'foo', 'foo'::DECIMAL
SELECT (DECIMAL ('foo')), (('foo')::DECIMAL) -- fully parenthesized
SELECT DECIMAL '_', '_'::DECIMAL -- literals removed
SELECT DECIMAL 'foo', 'foo'::DECIMAL -- identifiers removed

parse
SELECT NUMERIC 'foo'
----
SELECT DECIMAL 'foo' -- normalized!
SELECT (DECIMAL ('foo')) -- fully parenthesized
SELECT DECIMAL '_' -- literals removed
SELECT DECIMAL 'foo' -- identifiers removed


parse
SELECT CHAR 'foo', 'foo'::CHAR, CHAR(2) 'foo'
----
SELECT CHAR 'foo', 'foo'::CHAR, CHAR(2) 'foo'
SELECT (CHAR ('foo')), (('foo')::CHAR), (CHAR(2) ('foo')) -- fully parenthesized
SELECT CHAR '_', '_'::CHAR, CHAR(2) '_' -- literals removed
SELECT CHAR 'foo', 'foo'::CHAR, CHAR(2) 'foo' -- identifiers removed

parse
SELECT VARCHAR 'foo', 'foo'::VARCHAR, VARCHAR(5) 'foo'
----
SELECT VARCHAR 'foo', 'foo'::VARCHAR, VARCHAR(5) 'foo'
SELECT (VARCHAR ('foo')), (('foo')::VARCHAR), (VARCHAR(5) ('foo')) -- fully parenthesized
SELECT VARCHAR '_', '_'::VARCHAR, VARCHAR(5) '_' -- literals removed
SELECT VARCHAR 'foo', 'foo'::VARCHAR, VARCHAR(5) 'foo' -- identifiers removed

parse
SELECT STRING 'foo', 'foo'::STRING, STRING(9) 'foo'
----
SELECT STRING 'foo', 'foo'::STRING, STRING(9) 'foo'
SELECT (STRING ('foo')), (('foo')::STRING), (STRING(9) ('foo')) -- fully parenthesized
SELECT STRING '_', '_'::STRING, STRING(9) '_' -- literals removed
SELECT STRING 'foo', 'foo'::STRING, STRING(9) 'foo' -- identifiers removed

parse
SELECT BYTES 'foo', 'foo'::BYTES
----
SELECT BYTES 'foo', 'foo'::BYTES
SELECT (BYTES ('foo')), (('foo')::BYTES) -- fully parenthesized
SELECT BYTES '_', '_'::BYTES -- literals removed
SELECT BYTES 'foo', 'foo'::BYTES -- identifiers removed

parse
SELECT DATE 'foo', 'foo'::DATE
----
SELECT DATE 'foo', 'foo'::DATE
SELECT (DATE ('foo')), (('foo')::DATE) -- fully parenthesized
SELECT DATE '_', '_'::DATE -- literals removed
SELECT DATE 'foo', 'foo'::DATE -- identifiers removed

parse
SELECT TIME 'foo', 'foo'::TIME
----
SELECT TIME 'foo', 'foo'::TIME
SELECT (TIME ('foo')), (('foo')::TIME) -- fully parenthesized
SELECT TIME '_', '_'::TIME -- literals removed
SELECT TIME 'foo', 'foo'::TIME -- identifiers removed

parse
SELECT TIMESTAMP 'foo', 'foo'::TIMESTAMP
----
SELECT TIMESTAMP 'foo', 'foo'::TIMESTAMP
SELECT (TIMESTAMP ('foo')), (('foo')::TIMESTAMP) -- fully parenthesized
SELECT TIMESTAMP '_', '_'::TIMESTAMP -- literals removed
SELECT TIMESTAMP 'foo', 'foo'::TIMESTAMP -- identifiers removed

parse
SELECT TIMESTAMPTZ 'foo', 'foo'::TIMESTAMPTZ
----
SELECT TIMESTAMPTZ 'foo', 'foo'::TIMESTAMPTZ
SELECT (TIMESTAMPTZ ('foo')), (('foo')::TIMESTAMPTZ) -- fully parenthesized
SELECT TIMESTAMPTZ '_', '_'::TIMESTAMPTZ -- literals removed
SELECT TIMESTAMPTZ 'foo', 'foo'::TIMESTAMPTZ -- identifiers removed

parse
SELECT TIMESTAMP WITHOUT TIME ZONE 'foo'
----
SELECT TIMESTAMP 'foo' -- normalized!
SELECT (TIMESTAMP ('foo')) -- fully parenthesized
SELECT TIMESTAMP '_' -- literals removed
SELECT TIMESTAMP 'foo' -- identifiers removed

parse
SELECT 'a'::TIMESTAMP(3)
----
SELECT 'a'::TIMESTAMP(3)
SELECT (('a')::TIMESTAMP(3)) -- fully parenthesized
SELECT '_'::TIMESTAMP(3) -- literals removed
SELECT 'a'::TIMESTAMP(3) -- identifiers removed

parse
SELECT 'a'::TIMESTAMP(3) WITHOUT TIME ZONE
----
SELECT 'a'::TIMESTAMP(3) -- normalized!
SELECT (('a')::TIMESTAMP(3)) -- fully parenthesized
SELECT '_'::TIMESTAMP(3) -- literals removed
SELECT 'a'::TIMESTAMP(3) -- identifiers removed

parse
SELECT 'a'::TIMESTAMPTZ(3)
----
SELECT 'a'::TIMESTAMPTZ(3)
SELECT (('a')::TIMESTAMPTZ(3)) -- fully parenthesized
SELECT '_'::TIMESTAMPTZ(3) -- literals removed
SELECT 'a'::TIMESTAMPTZ(3) -- identifiers removed

parse
SELECT 'a'::TIMESTAMP(3) WITH TIME ZONE
----
SELECT 'a'::TIMESTAMPTZ(3) -- normalized!
SELECT (('a')::TIMESTAMPTZ(3)) -- fully parenthesized
SELECT '_'::TIMESTAMPTZ(3) -- literals removed
SELECT 'a'::TIMESTAMPTZ(3) -- identifiers removed

parse
SELECT TIMESTAMP(3) 'a'
----
SELECT TIMESTAMP(3) 'a'
SELECT (TIMESTAMP(3) ('a')) -- fully parenthesized
SELECT TIMESTAMP(3) '_' -- literals removed
SELECT TIMESTAMP(3) 'a' -- identifiers removed

parse
SELECT TIMESTAMPTZ(3) 'a'
----
SELECT TIMESTAMPTZ(3) 'a'
SELECT (TIMESTAMPTZ(3) ('a')) -- fully parenthesized
SELECT TIMESTAMPTZ(3) '_' -- literals removed
SELECT TIMESTAMPTZ(3) 'a' -- identifiers removed


parse
SELECT CAST('foo' AS TIMESTAMP WITHOUT TIME ZONE)
----
SELECT CAST('foo' AS TIMESTAMP) -- normalized!
SELECT (CAST(('foo') AS TIMESTAMP)) -- fully parenthesized
SELECT CAST('_' AS TIMESTAMP) -- literals removed
SELECT CAST('foo' AS TIMESTAMP) -- identifiers removed

parse
SELECT CAST(1 AS "timestamp")
----
SELECT CAST(1 AS TIMESTAMP) -- normalized!
SELECT (CAST((1) AS TIMESTAMP)) -- fully parenthesized
SELECT CAST(_ AS TIMESTAMP) -- literals removed
SELECT CAST(1 AS TIMESTAMP) -- identifiers removed

parse
SELECT JSONB 'foo', 'foo'::JSONB
----
SELECT JSONB 'foo', 'foo'::JSONB
SELECT (JSONB ('foo')), (('foo')::JSONB) -- fully parenthesized
SELECT JSONB '_', '_'::JSONB -- literals removed
SELECT JSONB 'foo', 'foo'::JSONB -- identifiers removed

parse
SELECT '{}'::JSONB ? 'a' = false
----
SELECT ('{}'::JSONB ? 'a') = false -- normalized!
SELECT ((((('{}')::JSONB) ? ('a'))) = (false)) -- fully parenthesized
SELECT ('_'::JSONB ? '_') = _ -- literals removed
SELECT ('{}'::JSONB ? 'a') = false -- identifiers removed

parse
SELECT '{}'::JSONB ?| 'a' = false
----
SELECT ('{}'::JSONB ?| 'a') = false -- normalized!
SELECT ((((('{}')::JSONB) ?| ('a'))) = (false)) -- fully parenthesized
SELECT ('_'::JSONB ?| '_') = _ -- literals removed
SELECT ('{}'::JSONB ?| 'a') = false -- identifiers removed

parse
SELECT '{}'::JSONB ?& 'a' = false
----
SELECT ('{}'::JSONB ?& 'a') = false -- normalized!
SELECT ((((('{}')::JSONB) ?& ('a'))) = (false)) -- fully parenthesized
SELECT ('_'::JSONB ?& '_') = _ -- literals removed
SELECT ('{}'::JSONB ?& 'a') = false -- identifiers removed

parse
SELECT '{}'::JSONB @> '{}'::JSONB = false
----
SELECT ('{}'::JSONB @> '{}'::JSONB) = false -- normalized!
SELECT ((((('{}')::JSONB) @> (('{}')::JSONB))) = (false)) -- fully parenthesized
SELECT ('_'::JSONB @> '_'::JSONB) = _ -- literals removed
SELECT ('{}'::JSONB @> '{}'::JSONB) = false -- identifiers removed

parse
SELECT '{}'::JSONB <@ '{}'::JSONB = false
----
SELECT ('{}'::JSONB <@ '{}'::JSONB) = false -- normalized!
SELECT ((((('{}')::JSONB) <@ (('{}')::JSONB))) = (false)) -- fully parenthesized
SELECT ('_'::JSONB <@ '_'::JSONB) = _ -- literals removed
SELECT ('{}'::JSONB <@ '{}'::JSONB) = false -- identifiers removed


parse
SELECT 'foo'::DECIMAL(1)
----
SELECT 'foo'::DECIMAL(1)
SELECT (('foo')::DECIMAL(1)) -- fully parenthesized
SELECT '_'::DECIMAL(1) -- literals removed
SELECT 'foo'::DECIMAL(1) -- identifiers removed

parse
SELECT 'foo'::DECIMAL(2,1)
----
SELECT 'foo'::DECIMAL(2,1)
SELECT (('foo')::DECIMAL(2,1)) -- fully parenthesized
SELECT '_'::DECIMAL(2,1) -- literals removed
SELECT 'foo'::DECIMAL(2,1) -- identifiers removed

parse
SELECT 'foo'::BIT
----
SELECT 'foo'::BIT
SELECT (('foo')::BIT) -- fully parenthesized
SELECT '_'::BIT -- literals removed
SELECT 'foo'::BIT -- identifiers removed

parse
SELECT 'foo'::BIT(3)
----
SELECT 'foo'::BIT(3)
SELECT (('foo')::BIT(3)) -- fully parenthesized
SELECT '_'::BIT(3) -- literals removed
SELECT 'foo'::BIT(3) -- identifiers removed

parse
SELECT 'foo'::BIT(0)
----
SELECT 'foo'::BIT(0)
SELECT (('foo')::BIT(0)) -- fully parenthesized
SELECT '_'::BIT(0) -- literals removed
SELECT 'foo'::BIT(0) -- identifiers removed

parse
SELECT 'foo'::VARBIT(3)
----
SELECT 'foo'::VARBIT(3)
SELECT (('foo')::VARBIT(3)) -- fully parenthesized
SELECT '_'::VARBIT(3) -- literals removed
SELECT 'foo'::VARBIT(3) -- identifiers removed

parse
SELECT 'foo'::CHAR(3)
----
SELECT 'foo'::CHAR(3)
SELECT (('foo')::CHAR(3)) -- fully parenthesized
SELECT '_'::CHAR(3) -- literals removed
SELECT 'foo'::CHAR(3) -- identifiers removed

parse
SELECT 'foo'::VARCHAR(3)
----
SELECT 'foo'::VARCHAR(3)
SELECT (('foo')::VARCHAR(3)) -- fully parenthesized
SELECT '_'::VARCHAR(3) -- literals removed
SELECT 'foo'::VARCHAR(3) -- identifiers removed

parse
SELECT 'foo'::STRING(3)
----
SELECT 'foo'::STRING(3)
SELECT (('foo')::STRING(3)) -- fully parenthesized
SELECT '_'::STRING(3) -- literals removed
SELECT 'foo'::STRING(3) -- identifiers removed

parse
SELECT 'foo'::TIMESTAMP(6)
----
SELECT 'foo'::TIMESTAMP(6)
SELECT (('foo')::TIMESTAMP(6)) -- fully parenthesized
SELECT '_'::TIMESTAMP(6) -- literals removed
SELECT 'foo'::TIMESTAMP(6) -- identifiers removed

parse
SELECT 'foo'::TIMESTAMPTZ(6)
----
SELECT 'foo'::TIMESTAMPTZ(6)
SELECT (('foo')::TIMESTAMPTZ(6)) -- fully parenthesized
SELECT '_'::TIMESTAMPTZ(6) -- literals removed
SELECT 'foo'::TIMESTAMPTZ(6) -- identifiers removed

parse
SELECT 'foo'::TIME(6)
----
SELECT 'foo'::TIME(6)
SELECT (('foo')::TIME(6)) -- fully parenthesized
SELECT '_'::TIME(6) -- literals removed
SELECT 'foo'::TIME(6) -- identifiers removed

parse
SELECT 'a'::TIME(3)
----
SELECT 'a'::TIME(3)
SELECT (('a')::TIME(3)) -- fully parenthesized
SELECT '_'::TIME(3) -- literals removed
SELECT 'a'::TIME(3) -- identifiers removed

parse
SELECT 'a'::TIME(3) WITHOUT TIME ZONE
----
SELECT 'a'::TIME(3) -- normalized!
SELECT (('a')::TIME(3)) -- fully parenthesized
SELECT '_'::TIME(3) -- literals removed
SELECT 'a'::TIME(3) -- identifiers removed

parse
SELECT 'a'::TIMETZ(3)
----
SELECT 'a'::TIMETZ(3)
SELECT (('a')::TIMETZ(3)) -- fully parenthesized
SELECT '_'::TIMETZ(3) -- literals removed
SELECT 'a'::TIMETZ(3) -- identifiers removed

parse
SELECT 'a'::TIME(3) WITH TIME ZONE
----
SELECT 'a'::TIMETZ(3) -- normalized!
SELECT (('a')::TIMETZ(3)) -- fully parenthesized
SELECT '_'::TIMETZ(3) -- literals removed
SELECT 'a'::TIMETZ(3) -- identifiers removed

parse
SELECT TIME(3) 'a'
----
SELECT TIME(3) 'a'
SELECT (TIME(3) ('a')) -- fully parenthesized
SELECT TIME(3) '_' -- literals removed
SELECT TIME(3) 'a' -- identifiers removed

parse
SELECT TIMETZ(3) 'a'
----
SELECT TIMETZ(3) 'a'
SELECT (TIMETZ(3) ('a')) -- fully parenthesized
SELECT TIMETZ(3) '_' -- literals removed
SELECT TIMETZ(3) 'a' -- identifiers removed


parse
SELECT '0'::INTERVAL
----
SELECT '0'::INTERVAL
SELECT (('0')::INTERVAL) -- fully parenthesized
SELECT '_'::INTERVAL -- literals removed
SELECT '0'::INTERVAL -- identifiers removed

parse
SELECT INTERVAL '0'
----
SELECT '0'::INTERVAL -- normalized!
SELECT (('0')::INTERVAL) -- fully parenthesized
SELECT '_'::INTERVAL -- literals removed
SELECT '0'::INTERVAL -- identifiers removed

parse
SELECT INTERVAL '1' SECOND
----
SELECT '1'::INTERVAL SECOND -- normalized!
SELECT (('1')::INTERVAL SECOND) -- fully parenthesized
SELECT '_'::INTERVAL SECOND -- literals removed
SELECT '1'::INTERVAL SECOND -- identifiers removed

parse
SELECT INTERVAL(3) '12.1234s'
----
SELECT '12.1234s'::INTERVAL(3) -- normalized!
SELECT (('12.1234s')::INTERVAL(3)) -- fully parenthesized
SELECT '_'::INTERVAL(3) -- literals removed
SELECT '12.1234s'::INTERVAL(3) -- identifiers removed

parse
SELECT INTERVAL '12.1234s' SECOND(3)
----
SELECT '12.1234s'::INTERVAL SECOND(3) -- normalized!
SELECT (('12.1234s')::INTERVAL SECOND(3)) -- fully parenthesized
SELECT '_'::INTERVAL SECOND(3) -- literals removed
SELECT '12.1234s'::INTERVAL SECOND(3) -- identifiers removed

parse
SELECT INTERVAL '14.7899s' SECOND(3)
----
SELECT '14.7899s'::INTERVAL SECOND(3) -- normalized!
SELECT (('14.7899s')::INTERVAL SECOND(3)) -- fully parenthesized
SELECT '_'::INTERVAL SECOND(3) -- literals removed
SELECT '14.7899s'::INTERVAL SECOND(3) -- identifiers removed

parse
SELECT '11s'::INTERVAL(3)
----
SELECT '11s'::INTERVAL(3)
SELECT (('11s')::INTERVAL(3)) -- fully parenthesized
SELECT '_'::INTERVAL(3) -- literals removed
SELECT '11s'::INTERVAL(3) -- identifiers removed

parse
SELECT '10:00:13.123456'::INTERVAL SECOND
----
SELECT '10:00:13.123456'::INTERVAL SECOND
SELECT (('10:00:13.123456')::INTERVAL SECOND) -- fully parenthesized
SELECT '_'::INTERVAL SECOND -- literals removed
SELECT '10:00:13.123456'::INTERVAL SECOND -- identifiers removed

parse
SELECT '10:00:13.123456'::INTERVAL SECOND(3)
----
SELECT '10:00:13.123456'::INTERVAL SECOND(3)
SELECT (('10:00:13.123456')::INTERVAL SECOND(3)) -- fully parenthesized
SELECT '_'::INTERVAL SECOND(3) -- literals removed
SELECT '10:00:13.123456'::INTERVAL SECOND(3) -- identifiers removed

parse
SELECT '10:00:13.123456'::INTERVAL MINUTE TO SECOND
----
SELECT '10:00:13.123456'::INTERVAL MINUTE TO SECOND
SELECT (('10:00:13.123456')::INTERVAL MINUTE TO SECOND) -- fully parenthesized
SELECT '_'::INTERVAL MINUTE TO SECOND -- literals removed
SELECT '10:00:13.123456'::INTERVAL MINUTE TO SECOND -- identifiers removed

parse
SELECT '10:00:13.123456'::INTERVAL MINUTE TO SECOND(3)
----
SELECT '10:00:13.123456'::INTERVAL MINUTE TO SECOND(3)
SELECT (('10:00:13.123456')::INTERVAL MINUTE TO SECOND(3)) -- fully parenthesized
SELECT '_'::INTERVAL MINUTE TO SECOND(3) -- literals removed
SELECT '10:00:13.123456'::INTERVAL MINUTE TO SECOND(3) -- identifiers removed

parse
SELECT INTERVAL 'foo'
----
SELECT 'foo'::INTERVAL -- normalized!
SELECT (('foo')::INTERVAL) -- fully parenthesized
SELECT '_'::INTERVAL -- literals removed
SELECT 'foo'::INTERVAL -- identifiers removed

parse
SELECT 'foo'::BOX2D
----
SELECT 'foo'::BOX2D
SELECT (('foo')::BOX2D) -- fully parenthesized
SELECT '_'::BOX2D -- literals removed
SELECT 'foo'::BOX2D -- identifiers removed

parse
SELECT 'foo'::GEOGRAPHY
----
SELECT 'foo'::GEOGRAPHY
SELECT (('foo')::GEOGRAPHY) -- fully parenthesized
SELECT '_'::GEOGRAPHY -- literals removed
SELECT 'foo'::GEOGRAPHY -- identifiers removed

parse
SELECT 'foo'::GEOGRAPHY(POINT,4326)
----
SELECT 'foo'::GEOGRAPHY(POINT,4326)
SELECT (('foo')::GEOGRAPHY(POINT,4326)) -- fully parenthesized
SELECT '_'::GEOGRAPHY(POINT,4326) -- literals removed
SELECT 'foo'::GEOGRAPHY(POINT,4326) -- identifiers removed

parse
SELECT 'foo'::GEOGRAPHY(POINT)
----
SELECT 'foo'::GEOGRAPHY(POINT)
SELECT (('foo')::GEOGRAPHY(POINT)) -- fully parenthesized
SELECT '_'::GEOGRAPHY(POINT) -- literals removed
SELECT 'foo'::GEOGRAPHY(POINT) -- identifiers removed

parse
SELECT 'foo'::GEOMETRY
----
SELECT 'foo'::GEOMETRY
SELECT (('foo')::GEOMETRY) -- fully parenthesized
SELECT '_'::GEOMETRY -- literals removed
SELECT 'foo'::GEOMETRY -- identifiers removed

parse
SELECT 'foo'::GEOMETRY(POINT)
----
SELECT 'foo'::GEOMETRY(POINT)
SELECT (('foo')::GEOMETRY(POINT)) -- fully parenthesized
SELECT '_'::GEOMETRY(POINT) -- literals removed
SELECT 'foo'::GEOMETRY(POINT) -- identifiers removed

parse
SELECT 'foo'::GEOMETRY(POINT,4326)
----
SELECT 'foo'::GEOMETRY(POINT,4326)
SELECT (('foo')::GEOMETRY(POINT,4326)) -- fully parenthesized
SELECT '_'::GEOMETRY(POINT,4326) -- literals removed
SELECT 'foo'::GEOMETRY(POINT,4326) -- identifiers removed

parse
SELECT '192.168.0.1'::INET
----
SELECT '192.168.0.1'::INET
SELECT (('192.168.0.1')::INET) -- fully parenthesized
SELECT '_'::INET -- literals removed
SELECT '192.168.0.1'::INET -- identifiers removed

parse
SELECT '192.168.0.1':::INET
----
SELECT '192.168.0.1':::INET
SELECT (('192.168.0.1'):::INET) -- fully parenthesized
SELECT '_':::INET -- literals removed
SELECT '192.168.0.1':::INET -- identifiers removed

parse
SELECT INET '192.168.0.1'
----
SELECT INET '192.168.0.1'
SELECT (INET ('192.168.0.1')) -- fully parenthesized
SELECT INET '_' -- literals removed
SELECT INET '192.168.0.1' -- identifiers removed

parse
SELECT b <<= c
----
SELECT inet_contained_by_or_equals(b, c) -- normalized!
SELECT (inet_contained_by_or_equals((b), (c))) -- fully parenthesized
SELECT inet_contained_by_or_equals(b, c) -- literals removed
SELECT inet_contained_by_or_equals(_, _) -- identifiers removed

parse
SELECT b >>= c
----
SELECT inet_contains_or_equals(b, c) -- normalized!
SELECT (inet_contains_or_equals((b), (c))) -- fully parenthesized
SELECT inet_contains_or_equals(b, c) -- literals removed
SELECT inet_contains_or_equals(_, _) -- identifiers removed


parse
SELECT 1:::REGTYPE
----
SELECT 1:::REGTYPE
SELECT ((1):::REGTYPE) -- fully parenthesized
SELECT _:::REGTYPE -- literals removed
SELECT 1:::REGTYPE -- identifiers removed

parse
SELECT 1:::REGPROC
----
SELECT 1:::REGPROC
SELECT ((1):::REGPROC) -- fully parenthesized
SELECT _:::REGPROC -- literals removed
SELECT 1:::REGPROC -- identifiers removed

parse
SELECT 1:::REGPROCEDURE
----
SELECT 1:::REGPROCEDURE
SELECT ((1):::REGPROCEDURE) -- fully parenthesized
SELECT _:::REGPROCEDURE -- literals removed
SELECT 1:::REGPROCEDURE -- identifiers removed

parse
SELECT 1:::REGCLASS
----
SELECT 1:::REGCLASS
SELECT ((1):::REGCLASS) -- fully parenthesized
SELECT _:::REGCLASS -- literals removed
SELECT 1:::REGCLASS -- identifiers removed

parse
SELECT 1:::REGNAMESPACE
----
SELECT 1:::REGNAMESPACE
SELECT ((1):::REGNAMESPACE) -- fully parenthesized
SELECT _:::REGNAMESPACE -- literals removed
SELECT 1:::REGNAMESPACE -- identifiers removed

parse
SELECT 1:::REGROLE
----
SELECT 1:::REGROLE
SELECT ((1):::REGROLE) -- fully parenthesized
SELECT _:::REGROLE -- literals removed
SELECT 1:::REGROLE -- identifiers removed

parse
SELECT 'a' AS "12345"
----
SELECT 'a' AS "12345"
SELECT ('a') AS "12345" -- fully parenthesized
SELECT '_' AS "12345" -- literals removed
SELECT 'a' AS _ -- identifiers removed

parse
SELECT 'a' AS "a""b"
----
SELECT 'a' AS "a""b"
SELECT ('a') AS "a""b" -- fully parenthesized
SELECT '_' AS "a""b" -- literals removed
SELECT 'a' AS _ -- identifiers removed

error
SELECT 'a' AS "a"
"b"
----
at or near "b": syntax error
DETAIL: source SQL:
SELECT 'a' AS "a"
"b"
^

error
SELECT 'a' AS "a"


"b"
----
----
at or near "b": syntax error
DETAIL: source SQL:
SELECT 'a' AS "a"


"b"
^
----
----

parse
SELECT 'a' AS clnm
----
SELECT 'a' AS clnm
SELECT ('a') AS clnm -- fully parenthesized
SELECT '_' AS clnm -- literals removed
SELECT 'a' AS _ -- identifiers removed

parse
SELECT 'a' AS primary
----
SELECT 'a' AS primary
SELECT ('a') AS primary -- fully parenthesized
SELECT '_' AS primary -- literals removed
SELECT 'a' AS _ -- identifiers removed

parse
SELECT 'a' AS like
----
SELECT 'a' AS like
SELECT ('a') AS like -- fully parenthesized
SELECT '_' AS like -- literals removed
SELECT 'a' AS _ -- identifiers removed

parse
SELECT 0xf0 FROM t
----
SELECT 0xf0 FROM t
SELECT (0xf0) FROM t -- fully parenthesized
SELECT _ FROM t -- literals removed
SELECT 0xf0 FROM _ -- identifiers removed

parse
SELECT 0xF0 FROM t
----
SELECT 0xF0 FROM t
SELECT (0xF0) FROM t -- fully parenthesized
SELECT _ FROM t -- literals removed
SELECT 0xF0 FROM _ -- identifiers removed

error
SELECT 0x FROM t
----
lexical error: invalid hexadecimal numeric literal
DETAIL: source SQL:
SELECT 0x FROM t
       ^

error
SELECT x'fail' FROM t
----
lexical error: invalid hexadecimal bytes literal
DETAIL: source SQL:
SELECT x'fail' FROM t
       ^

error
SELECT x'AAB' FROM t
----
lexical error: invalid hexadecimal bytes literal
DETAIL: source SQL:
SELECT x'AAB' FROM t
       ^

parse
SELECT CAST(1 AS STRING)
----
SELECT CAST(1 AS STRING)
SELECT (CAST((1) AS STRING)) -- fully parenthesized
SELECT CAST(_ AS STRING) -- literals removed
SELECT CAST(1 AS STRING) -- identifiers removed

parse
SELECT CAST(1 AS _int8)
----
SELECT CAST(1 AS INT8[]) -- normalized!
SELECT (CAST((1) AS INT8[])) -- fully parenthesized
SELECT CAST(_ AS INT8[]) -- literals removed
SELECT CAST(1 AS INT8[]) -- identifiers removed

parse
SELECT CAST(1 AS "_int8")
----
SELECT CAST(1 AS INT8[]) -- normalized!
SELECT (CAST((1) AS INT8[])) -- fully parenthesized
SELECT CAST(_ AS INT8[]) -- literals removed
SELECT CAST(1 AS INT8[]) -- identifiers removed

parse
SELECT SERIAL8 'foo', 'foo'::SERIAL8
----
SELECT INT8 'foo', 'foo'::INT8 -- normalized!
SELECT (INT8 ('foo')), (('foo')::INT8) -- fully parenthesized
SELECT INT8 '_', '_'::INT8 -- literals removed
SELECT INT8 'foo', 'foo'::INT8 -- identifiers removed


parse
SELECT ANNOTATE_TYPE(1, STRING)
----
SELECT ANNOTATE_TYPE(1, STRING)
SELECT (ANNOTATE_TYPE((1), STRING)) -- fully parenthesized
SELECT ANNOTATE_TYPE(_, STRING) -- literals removed
SELECT ANNOTATE_TYPE(1, STRING) -- identifiers removed

parse
SELECT (1 + 2).*
----
SELECT (1 + 2).*
SELECT ((((1) + (2))).*) -- fully parenthesized
SELECT (_ + _).* -- literals removed
SELECT (1 + 2).* -- identifiers removed

parse
SELECT (1 + 2).@1
----
SELECT (1 + 2).@1
SELECT ((((1) + (2))).@1) -- fully parenthesized
SELECT (_ + _).@1 -- literals removed
SELECT (1 + 2).@1 -- identifiers removed


parse
SELECT (1 + 2).col
----
SELECT (1 + 2).col
SELECT ((((1) + (2))).col) -- fully parenthesized
SELECT (_ + _).col -- literals removed
SELECT (1 + 2)._ -- identifiers removed

error
SELECT 1 + ANY ARRAY[1, 2, 3]
----
at or near "EOF": syntax error: + ANY <array> is invalid because "+" is not a boolean operator
DETAIL: source SQL:
SELECT 1 + ANY ARRAY[1, 2, 3]
                             ^

parse
SELECT (abc.def).col
----
SELECT (abc.def).col
SELECT (((abc.def)).col) -- fully parenthesized
SELECT (abc.def).col -- literals removed
SELECT (_._)._ -- identifiers removed

parse
SELECT (i.keys).col
----
SELECT (i.keys).col
SELECT (((i.keys)).col) -- fully parenthesized
SELECT (i.keys).col -- literals removed
SELECT (_._)._ -- identifiers removed

parse
SELECT (i.keys).*
----
SELECT (i.keys).*
SELECT (((i.keys)).*) -- fully parenthesized
SELECT (i.keys).* -- literals removed
SELECT (_._).* -- identifiers removed

parse
SELECT (i.keys).@1
----
SELECT (i.keys).@1
SELECT (((i.keys)).@1) -- fully parenthesized
SELECT (i.keys).@1 -- literals removed
SELECT (_._).@1 -- identifiers removed

parse
SELECT (ARRAY['a', 'b', 'c']).name
----
SELECT (ARRAY['a', 'b', 'c']).name
SELECT (((ARRAY[('a'), ('b'), ('c')])).name) -- fully parenthesized
SELECT (ARRAY['_', '_', __more1_10__]).name -- literals removed
SELECT (ARRAY['a', 'b', 'c'])._ -- identifiers removed

parse
SELECT 'a' LIKE '\a' ESCAPE '\'
----
SELECT like_escape('a', e'\\a', e'\\') -- normalized!
SELECT (like_escape(('a'), (e'\\a'), (e'\\'))) -- fully parenthesized
SELECT like_escape('_', '_', '_') -- literals removed
SELECT like_escape('a', e'\\a', e'\\') -- identifiers removed

parse
SELECT '\abc\' LIKE '-\___-\' ESCAPE '-'
----
SELECT like_escape(e'\\abc\\', e'-\\___-\\', '-') -- normalized!
SELECT (like_escape((e'\\abc\\'), (e'-\\___-\\'), ('-'))) -- fully parenthesized
SELECT like_escape('_', '_', '_') -- literals removed
SELECT like_escape(e'\\abc\\', e'-\\___-\\', '-') -- identifiers removed

parse
SELECT 'a' LIKE '\a' ESCAPE ''
----
SELECT like_escape('a', e'\\a', '') -- normalized!
SELECT (like_escape(('a'), (e'\\a'), (''))) -- fully parenthesized
SELECT like_escape('_', '_', '_') -- literals removed
SELECT like_escape('a', e'\\a', '') -- identifiers removed

parse
SELECT 'a' NOT LIKE '\a' ESCAPE '\'
----
SELECT not_like_escape('a', e'\\a', e'\\') -- normalized!
SELECT (not_like_escape(('a'), (e'\\a'), (e'\\'))) -- fully parenthesized
SELECT not_like_escape('_', '_', '_') -- literals removed
SELECT not_like_escape('a', e'\\a', e'\\') -- identifiers removed

parse
SELECT '\abc\' NOT LIKE '-\___-\' ESCAPE '-'
----
SELECT not_like_escape(e'\\abc\\', e'-\\___-\\', '-') -- normalized!
SELECT (not_like_escape((e'\\abc\\'), (e'-\\___-\\'), ('-'))) -- fully parenthesized
SELECT not_like_escape('_', '_', '_') -- literals removed
SELECT not_like_escape(e'\\abc\\', e'-\\___-\\', '-') -- identifiers removed

parse
SELECT 'a' NOT LIKE '\a' ESCAPE ''
----
SELECT not_like_escape('a', e'\\a', '') -- normalized!
SELECT (not_like_escape(('a'), (e'\\a'), (''))) -- fully parenthesized
SELECT not_like_escape('_', '_', '_') -- literals removed
SELECT not_like_escape('a', e'\\a', '') -- identifiers removed

parse
SELECT 'a' ILIKE '\a' ESCAPE '\'
----
SELECT ilike_escape('a', e'\\a', e'\\') -- normalized!
SELECT (ilike_escape(('a'), (e'\\a'), (e'\\'))) -- fully parenthesized
SELECT ilike_escape('_', '_', '_') -- literals removed
SELECT ilike_escape('a', e'\\a', e'\\') -- identifiers removed

parse
SELECT '\abc\' ILIKE '-\___-\' ESCAPE '-'
----
SELECT ilike_escape(e'\\abc\\', e'-\\___-\\', '-') -- normalized!
SELECT (ilike_escape((e'\\abc\\'), (e'-\\___-\\'), ('-'))) -- fully parenthesized
SELECT ilike_escape('_', '_', '_') -- literals removed
SELECT ilike_escape(e'\\abc\\', e'-\\___-\\', '-') -- identifiers removed

parse
SELECT 'a' ILIKE '\a' ESCAPE ''
----
SELECT ilike_escape('a', e'\\a', '') -- normalized!
SELECT (ilike_escape(('a'), (e'\\a'), (''))) -- fully parenthesized
SELECT ilike_escape('_', '_', '_') -- literals removed
SELECT ilike_escape('a', e'\\a', '') -- identifiers removed

parse
SELECT 'a' NOT ILIKE '\a' ESCAPE '\'
----
SELECT not_ilike_escape('a', e'\\a', e'\\') -- normalized!
SELECT (not_ilike_escape(('a'), (e'\\a'), (e'\\'))) -- fully parenthesized
SELECT not_ilike_escape('_', '_', '_') -- literals removed
SELECT not_ilike_escape('a', e'\\a', e'\\') -- identifiers removed

parse
SELECT '\abc\' NOT ILIKE '-\___-\' ESCAPE '-'
----
SELECT not_ilike_escape(e'\\abc\\', e'-\\___-\\', '-') -- normalized!
SELECT (not_ilike_escape((e'\\abc\\'), (e'-\\___-\\'), ('-'))) -- fully parenthesized
SELECT not_ilike_escape('_', '_', '_') -- literals removed
SELECT not_ilike_escape(e'\\abc\\', e'-\\___-\\', '-') -- identifiers removed

parse
SELECT 'a' NOT ILIKE '\a' ESCAPE ''
----
SELECT not_ilike_escape('a', e'\\a', '') -- normalized!
SELECT (not_ilike_escape(('a'), (e'\\a'), (''))) -- fully parenthesized
SELECT not_ilike_escape('_', '_', '_') -- literals removed
SELECT not_ilike_escape('a', e'\\a', '') -- identifiers removed

parse
SELECT 'a' SIMILAR TO '\a' ESCAPE '\'
----
SELECT similar_to_escape('a', e'\\a', e'\\') -- normalized!
SELECT (similar_to_escape(('a'), (e'\\a'), (e'\\'))) -- fully parenthesized
SELECT similar_to_escape('_', '_', '_') -- literals removed
SELECT similar_to_escape('a', e'\\a', e'\\') -- identifiers removed

parse
SELECT '\abc\' SIMILAR TO '-\___-\' ESCAPE '-'
----
SELECT similar_to_escape(e'\\abc\\', e'-\\___-\\', '-') -- normalized!
SELECT (similar_to_escape((e'\\abc\\'), (e'-\\___-\\'), ('-'))) -- fully parenthesized
SELECT similar_to_escape('_', '_', '_') -- literals removed
SELECT similar_to_escape(e'\\abc\\', e'-\\___-\\', '-') -- identifiers removed

parse
SELECT 'a' SIMILAR TO '\a' ESCAPE ''
----
SELECT similar_to_escape('a', e'\\a', '') -- normalized!
SELECT (similar_to_escape(('a'), (e'\\a'), (''))) -- fully parenthesized
SELECT similar_to_escape('_', '_', '_') -- literals removed
SELECT similar_to_escape('a', e'\\a', '') -- identifiers removed

parse
SELECT 'a' NOT SIMILAR TO '\a' ESCAPE '\'
----
SELECT not_similar_to_escape('a', e'\\a', e'\\') -- normalized!
SELECT (not_similar_to_escape(('a'), (e'\\a'), (e'\\'))) -- fully parenthesized
SELECT not_similar_to_escape('_', '_', '_') -- literals removed
SELECT not_similar_to_escape('a', e'\\a', e'\\') -- identifiers removed

parse
SELECT '\abc\' NOT SIMILAR TO '-\___-\' ESCAPE '-'
----
SELECT not_similar_to_escape(e'\\abc\\', e'-\\___-\\', '-') -- normalized!
SELECT (not_similar_to_escape((e'\\abc\\'), (e'-\\___-\\'), ('-'))) -- fully parenthesized
SELECT not_similar_to_escape('_', '_', '_') -- literals removed
SELECT not_similar_to_escape(e'\\abc\\', e'-\\___-\\', '-') -- identifiers removed

parse
SELECT 'a' NOT SIMILAR TO '\a' ESCAPE ''
----
SELECT not_similar_to_escape('a', e'\\a', '') -- normalized!
SELECT (not_similar_to_escape(('a'), (e'\\a'), (''))) -- fully parenthesized
SELECT not_similar_to_escape('_', '_', '_') -- literals removed
SELECT not_similar_to_escape('a', e'\\a', '') -- identifiers removed

parse
SELECT $$a'a$$
----
SELECT e'a\'a' -- normalized!
SELECT (e'a\'a') -- fully parenthesized
SELECT '_' -- literals removed
SELECT e'a\'a' -- identifiers removed

parse
SELECT $$a\\na$$
----
SELECT e'a\\\\na' -- normalized!
SELECT (e'a\\\\na') -- fully parenthesized
SELECT '_' -- literals removed
SELECT e'a\\\\na' -- identifiers removed

parse
SELECT $select$\\n$select$
----
SELECT e'\\\\n' -- normalized!
SELECT (e'\\\\n') -- fully parenthesized
SELECT '_' -- literals removed
SELECT e'\\\\n' -- identifiers removed

parse
SELECT $$a"a$$
----
SELECT 'a"a' -- normalized!
SELECT ('a"a') -- fully parenthesized
SELECT '_' -- literals removed
SELECT 'a"a' -- identifiers removed

parse
SELECT $$full$$
----
SELECT 'full' -- normalized!
SELECT ('full') -- fully parenthesized
SELECT '_' -- literals removed
SELECT 'full' -- identifiers removed

parse
SELECT $select$full$select$
----
SELECT 'full' -- normalized!
SELECT ('full') -- fully parenthesized
SELECT '_' -- literals removed
SELECT 'full' -- identifiers removed

parse
SELECT $select$a$$b$select$
----
SELECT 'a$$b' -- normalized!
SELECT ('a$$b') -- fully parenthesized
SELECT '_' -- literals removed
SELECT 'a$$b' -- identifiers removed

parse
SELECT $$Dianne's horse$$
----
SELECT e'Dianne\'s horse' -- normalized!
SELECT (e'Dianne\'s horse') -- fully parenthesized
SELECT '_' -- literals removed
SELECT e'Dianne\'s horse' -- identifiers removed

parse
SELECT $SomeTag$Dianne's horse$SomeTag$
----
SELECT e'Dianne\'s horse' -- normalized!
SELECT (e'Dianne\'s horse') -- fully parenthesized
SELECT '_' -- literals removed
SELECT e'Dianne\'s horse' -- identifiers removed

parse
SELECT $function$
BEGIN
RETURN ($1 ~ $q$[\t\r\n\v\\]$q$);
END;
$function$
----
SELECT e'\nBEGIN\nRETURN ($1 ~ $q$[\\t\\r\\n\\v\\\\]$q$);\nEND;\n' -- normalized!
SELECT (e'\nBEGIN\nRETURN ($1 ~ $q$[\\t\\r\\n\\v\\\\]$q$);\nEND;\n') -- fully parenthesized
SELECT '_' -- literals removed
SELECT e'\nBEGIN\nRETURN ($1 ~ $q$[\\t\\r\\n\\v\\\\]$q$);\nEND;\n' -- identifiers removed

parse
SELECT a IS NAN
----
SELECT a = 'NaN' -- normalized!
SELECT ((a) = ('NaN')) -- fully parenthesized
SELECT a = _ -- literals removed
SELECT _ = 'NaN' -- identifiers removed

parse
SELECT a IS NOT NAN
----
SELECT a != 'NaN' -- normalized!
SELECT ((a) != ('NaN')) -- fully parenthesized
SELECT a != _ -- literals removed
SELECT _ != 'NaN' -- identifiers removed

parse
SELECT 1+COALESCE(NULL, 'a', x)-ARRAY[3.14]
----
SELECT (1 + COALESCE(NULL, 'a', x)) - ARRAY[3.14] -- normalized!
SELECT ((((1) + (COALESCE((NULL), ('a'), (x))))) - (ARRAY[(3.14)])) -- fully parenthesized
SELECT (_ + COALESCE(_, '_', x)) - ARRAY[_] -- literals removed
SELECT (1 + COALESCE(NULL, 'a', _)) - ARRAY[3.14] -- identifiers removed

parse
SELECT 1 OPERATOR(+) 2, 1 OPERATOR(pg_catalog.+) 2
----
SELECT 1 OPERATOR(+) 2, 1 OPERATOR(+) 2 -- normalized!
SELECT ((1) OPERATOR(+) (2)), ((1) OPERATOR(+) (2)) -- fully parenthesized
SELECT _ OPERATOR(+) _, _ OPERATOR(+) _ -- literals removed
SELECT 1 OPERATOR(+) 2, 1 OPERATOR(+) 2 -- identifiers removed

parse
SELECT 1 OPERATOR(<<) 2, 1 OPERATOR(pg_catalog.<<) 2
----
SELECT 1 OPERATOR(<<) 2, 1 OPERATOR(<<) 2 -- normalized!
SELECT ((1) OPERATOR(<<) (2)), ((1) OPERATOR(<<) (2)) -- fully parenthesized
SELECT _ OPERATOR(<<) _, _ OPERATOR(<<) _ -- literals removed
SELECT 1 OPERATOR(<<) 2, 1 OPERATOR(<<) 2 -- identifiers removed

parse
SELECT OPERATOR(+) 1, OPERATOR(-) 1, OPERATOR(~) 1, OPERATOR(|/) 1, OPERATOR(||/) 1
----
SELECT OPERATOR(+)1, OPERATOR(-)(1), OPERATOR(~)1, OPERATOR(|/)1, OPERATOR(||/)1 -- normalized!
SELECT (OPERATOR(+)(1)), (OPERATOR(-)((1))), (OPERATOR(~)(1)), (OPERATOR(|/)(1)), (OPERATOR(||/)(1)) -- fully parenthesized
SELECT OPERATOR(+)_, OPERATOR(-)(_), OPERATOR(~)_, OPERATOR(|/)_, OPERATOR(||/)_ -- literals removed
SELECT OPERATOR(+)1, OPERATOR(-)(1), OPERATOR(~)1, OPERATOR(|/)1, OPERATOR(||/)1 -- identifiers removed

parse
SELECT OPERATOR ( ~ ) 1 COLLATE ident AS ILIKE FROM ident
----
SELECT OPERATOR(~)1 COLLATE ident AS ilike FROM ident -- normalized!
SELECT (OPERATOR(~)((1) COLLATE ident)) AS ilike FROM ident -- fully parenthesized
SELECT OPERATOR(~)_ COLLATE ident AS ilike FROM ident -- literals removed
SELECT OPERATOR(~)1 COLLATE ident AS _ FROM _ -- identifiers removed

error
SELECT OPERATOR(#) 5
----
at or near "EOF": syntax error: unknown unary operator #
DETAIL: source SQL:
SELECT OPERATOR(#) 5
                    ^

error
SELECT2 1
----
at or near "select2": syntax error
DETAIL: source SQL:
SELECT2 1
^

error
SELECT 1 FROM (t)
----
at or near ")": syntax error
DETAIL: source SQL:
SELECT 1 FROM (t)
                ^
HINT: try \h <SOURCE>

error
SELECT 1 /* hello
----
lexical error: unterminated comment
DETAIL: source SQL:
SELECT 1 /* hello
         ^

error
SELECT '1
----
lexical error: unterminated string
DETAIL: source SQL:
SELECT '1
       ^

error
SELECT family FROM test
----
at or near "from": syntax error
DETAIL: source SQL:
SELECT family FROM test
              ^

parse
SELECT FROM t
----
SELECT  FROM t -- normalized!
SELECT  FROM t -- fully parenthesized
SELECT  FROM t -- literals removed
SELECT  FROM _ -- identifiers removed

parse
SELECT ALL FROM t
----
SELECT  FROM t -- normalized!
SELECT  FROM t -- fully parenthesized
SELECT  FROM t -- literals removed
SELECT  FROM _ -- identifiers removed

error
SELECT DISTINCT FROM test
----
at or near "from": syntax error
DETAIL: source SQL:
SELECT DISTINCT FROM test
                ^

error
SELECT $0
----
lexical error: placeholder index must be between 1 and 65536
DETAIL: source SQL:
SELECT $0
       ^

error
SELECT $-1
----
at or near "$": syntax error
DETAIL: source SQL:
SELECT $-1
       ^

error
SELECT $123456789
----
lexical error: placeholder index must be between 1 and 65536
DETAIL: source SQL:
SELECT $123456789
       ^

error
SELECT (0) FROM y[array[]]
----
at or near "[": syntax error
DETAIL: source SQL:
SELECT (0) FROM y[array[]]
                 ^

parse
SELECT ''::void
----
SELECT ''::VOID -- normalized!
SELECT (('')::VOID) -- fully parenthesized
SELECT '_'::VOID -- literals removed
SELECT ''::VOID -- identifiers removed

parse
SELECT '':::void
----
SELECT '':::VOID -- normalized!
SELECT ((''):::VOID) -- fully parenthesized
SELECT '_':::VOID -- literals removed
SELECT '':::VOID -- identifiers removed

error
SELECT ''::void[]
----
at or near "EOF": syntax error: type void[] does not exist
DETAIL: source SQL:
SELECT ''::void[]
                 ^

parse
SELECT ''::trigger
----
SELECT ''::TRIGGER -- normalized!
SELECT (('')::TRIGGER) -- fully parenthesized
SELECT '_'::TRIGGER -- literals removed
SELECT ''::TRIGGER -- identifiers removed

parse
SELECT '':::trigger
----
SELECT '':::TRIGGER -- normalized!
SELECT ((''):::TRIGGER) -- fully parenthesized
SELECT '_':::TRIGGER -- literals removed
SELECT '':::TRIGGER -- identifiers removed

error
SELECT ''::trigger[]
----
at or near "EOF": syntax error: type trigger[] does not exist
DETAIL: source SQL:
SELECT ''::trigger[]
                    ^

parse
SELECT overlaps(
TIMESTAMP '2000-01-01 00:00:00',
TIMESTAMP '2000-01-01 01:00:00',
TIMESTAMP '2000-01-01 00:30:00',
TIMESTAMP '2000-01-01 01:30:00');
----
SELECT overlaps(TIMESTAMP '2000-01-01 00:00:00', TIMESTAMP '2000-01-01 01:00:00', TIMESTAMP '2000-01-01 00:30:00', TIMESTAMP '2000-01-01 01:30:00') -- normalized!
SELECT (overlaps((TIMESTAMP ('2000-01-01 00:00:00')), (TIMESTAMP ('2000-01-01 01:00:00')), (TIMESTAMP ('2000-01-01 00:30:00')), (TIMESTAMP ('2000-01-01 01:30:00')))) -- fully parenthesized
SELECT overlaps(TIMESTAMP '_', TIMESTAMP '_', TIMESTAMP '_', TIMESTAMP '_') -- literals removed
SELECT _(TIMESTAMP '2000-01-01 00:00:00', TIMESTAMP '2000-01-01 01:00:00', TIMESTAMP '2000-01-01 00:30:00', TIMESTAMP '2000-01-01 01:30:00') -- identifiers removed

parse
SELECT
(TIMESTAMP '2000-01-01 00:00:00',
TIMESTAMP '2000-01-01 01:00:00')
OVERLAPS
(TIMESTAMP '2000-01-01 00:30:00',
TIMESTAMP '2000-01-01 01:30:00');
----
SELECT overlaps(TIMESTAMP '2000-01-01 00:00:00', TIMESTAMP '2000-01-01 01:00:00', TIMESTAMP '2000-01-01 00:30:00', TIMESTAMP '2000-01-01 01:30:00') -- normalized!
SELECT (overlaps((TIMESTAMP ('2000-01-01 00:00:00')), (TIMESTAMP ('2000-01-01 01:00:00')), (TIMESTAMP ('2000-01-01 00:30:00')), (TIMESTAMP ('2000-01-01 01:30:00')))) -- fully parenthesized
SELECT overlaps(TIMESTAMP '_', TIMESTAMP '_', TIMESTAMP '_', TIMESTAMP '_') -- literals removed
SELECT overlaps(TIMESTAMP '2000-01-01 00:00:00', TIMESTAMP '2000-01-01 01:00:00', TIMESTAMP '2000-01-01 00:30:00', TIMESTAMP '2000-01-01 01:30:00') -- identifiers removed

error
SELECT
(DATE '2000-01-03',
DATE '2000-02-03',
DATE '2000-03-03')
OVERLAPS
(DATE '2000-01-03',
DATE '2000-01-04');
----
at or near ")": syntax error: wrong number of parameters on left side of OVERLAPS expression
DETAIL: source SQL:
SELECT
(DATE '2000-01-03',
DATE '2000-02-03',
DATE '2000-03-03')
OVERLAPS
(DATE '2000-01-03',
DATE '2000-01-04')
                 ^

error
SELECT
(DATE '2000-02-03',
DATE '2000-03-03')
OVERLAPS
(DATE '2000-01-03',
DATE '2000-01-03',
DATE '2000-01-04');
----
at or near ")": syntax error: wrong number of parameters on right side of OVERLAPS expression
DETAIL: source SQL:
SELECT
(DATE '2000-02-03',
DATE '2000-03-03')
OVERLAPS
(DATE '2000-01-03',
DATE '2000-01-03',
DATE '2000-01-04')
                 ^

error
SELECT
(DATE '2000-01-03')
OVERLAPS
(DATE '2000-01-03',
DATE '2000-01-04');
----
at or near "overlaps": syntax error
DETAIL: source SQL:
SELECT
(DATE '2000-01-03')
OVERLAPS
^

error
SELECT
(DATE '2000-02-03',
DATE '2000-03-03')
OVERLAPS
(DATE '2000-01-03');
----
at or near ")": syntax error
DETAIL: source SQL:
SELECT
(DATE '2000-02-03',
DATE '2000-03-03')
OVERLAPS
(DATE '2000-01-03')
                  ^

parse
SELECT NOT ('a' ~ ANY (ARRAY['x']:::STRING[]))
----
SELECT NOT ('a' = ANY (ARRAY['x']:::STRING[])) -- normalized!
SELECT (NOT (((('a') = ANY ((((ARRAY[('x')]):::STRING[]))))))) -- fully parenthesized
SELECT NOT ('_' = ANY (ARRAY['_']:::STRING[])) -- literals removed
SELECT NOT ('a' = ANY (ARRAY['x']:::STRING[])) -- identifiers removed

parse
SELECT ('a' !~ ANY (ARRAY['x']:::STRING[]))
----
SELECT ('a' !~ ANY (ARRAY['x']:::STRING[]))
SELECT (((('a') !~ ANY ((((ARRAY[('x')]):::STRING[])))))) -- fully parenthesized
SELECT ('_' !~ ANY (ARRAY['_']:::STRING[])) -- literals removed
SELECT ('a' !~ ANY (ARRAY['x']:::STRING[])) -- identifiers removed

parse
SELECT my_func('a', 1, true)
----
SELECT my_func('a', 1, true)
SELECT (my_func(('a'), (1), (true))) -- fully parenthesized
SELECT my_func('_', _, _) -- literals removed
SELECT _('a', 1, true) -- identifiers removed

parse
SELECT "[1,2]" <-> "[3,4]"
----
SELECT "[1,2]" <-> "[3,4]"
SELECT (("[1,2]") <-> ("[3,4]")) -- fully parenthesized
SELECT "[1,2]" <-> "[3,4]" -- literals removed
SELECT _ <-> _ -- identifiers removed

parse
SELECT "[2,2]" <=> "[3,4]"
----
SELECT "[2,2]" <=> "[3,4]"
SELECT (("[2,2]") <=> ("[3,4]")) -- fully parenthesized
SELECT "[2,2]" <=> "[3,4]" -- literals removed
SELECT _ <=> _ -- identifiers removed

parse
SELECT "[2,2]" <#> "[3,4]"
----
SELECT "[2,2]" <#> "[3,4]"
SELECT (("[2,2]") <#> ("[3,4]")) -- fully parenthesized
SELECT "[2,2]" <#> "[3,4]" -- literals removed
SELECT _ <#> _ -- identifiers removed

error
SELECT "[2,2]" <# "[3,4]"
----
at or near "#": syntax error
DETAIL: source SQL:
SELECT "[2,2]" <# "[3,4]"
                ^

parse
SELECT "[2,2]" <- "[3,4]"
----
SELECT "[2,2]" < (-"[3,4]") -- normalized!
SELECT (("[2,2]") < ((-("[3,4]")))) -- fully parenthesized
SELECT "[2,2]" < (-"[3,4]") -- literals removed
SELECT _ < (-_) -- identifiers removed
