## Escaping may change since the scanning process loses information
## (you can write e'\'' or ''''), but these are the idempotent cases.
## Generally, anything that needs to escape plus \ and ' leads to an
## escaped string.

# This test checks support for comments.
parse
SELECT 1 FROM t -- hello world
----
SELECT 1 FROM t -- normalized!
SELECT (1) FROM t -- fully parenthesized
SELECT _ FROM t -- literals removed
SELECT 1 FROM _ -- identifiers removed

parse
SELECT /* hello world */ 1 FROM t
----
SELECT 1 FROM t -- normalized!
SELECT (1) FROM t -- fully parenthesized
SELECT _ FROM t -- literals removed
SELECT 1 FROM _ -- identifiers removed

parse
SELECT /* hello */ 1 FROM /* world */ t
----
SELECT 1 FROM t -- normalized!
SELECT (1) FROM t -- fully parenthesized
SELECT _ FROM t -- literals removed
SELECT 1 FROM _ -- identifiers removed

parse
SELECT e'a\'a' FROM t
----
SELECT e'a\'a' FROM t
SELECT (e'a\'a') FROM t -- fully parenthesized
SELECT '_' FROM t -- literals removed
SELECT e'a\'a' FROM _ -- identifiers removed

parse
SELECT e'a\\\\na' FROM t
----
SELECT e'a\\\\na' FROM t
SELECT (e'a\\\\na') FROM t -- fully parenthesized
SELECT '_' FROM t -- literals removed
SELECT e'a\\\\na' FROM _ -- identifiers removed

parse
SELECT e'\\\\n' FROM t
----
SELECT e'\\\\n' FROM t
SELECT (e'\\\\n') FROM t -- fully parenthesized
SELECT '_' FROM t -- literals removed
SELECT e'\\\\n' FROM _ -- identifiers removed

parse
SELECT "a""a" FROM t
----
SELECT "a""a" FROM t
SELECT ("a""a") FROM t -- fully parenthesized
SELECT "a""a" FROM t -- literals removed
SELECT _ FROM _ -- identifiers removed

parse
SELECT a FROM "t\n" -- no escaping in sql identifiers
----
SELECT a FROM "t\n" -- normalized!
SELECT (a) FROM "t\n" -- fully parenthesized
SELECT a FROM "t\n" -- literals removed
SELECT _ FROM _ -- identifiers removed

parse
SELECT a FROM "t""" -- no escaping in sql identifiers
----
SELECT a FROM "t""" -- normalized!
SELECT (a) FROM "t""" -- fully parenthesized
SELECT a FROM "t""" -- literals removed
SELECT _ FROM _ -- identifiers removed

parse
SELECT "full" FROM t -- must quote column name keyword
----
SELECT "full" FROM t -- normalized!
SELECT ("full") FROM t -- fully parenthesized
SELECT "full" FROM t -- literals removed
SELECT _ FROM _ -- identifiers removed

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

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

parse
SELECT 1, 2 FROM t
----
SELECT 1, 2 FROM t
SELECT (1), (2) FROM t -- fully parenthesized
SELECT _, _ FROM t -- literals removed
SELECT 1, 2 FROM _ -- identifiers removed

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

parse
SELECT "*" FROM t
----
SELECT "*" FROM t
SELECT ("*") FROM t -- fully parenthesized
SELECT "*" FROM t -- literals removed
SELECT _ FROM _ -- identifiers removed

parse
SELECT "a'a" FROM t
----
SELECT "a'a" FROM t
SELECT ("a'a") FROM t -- fully parenthesized
SELECT "a'a" FROM t -- literals removed
SELECT _ FROM _ -- identifiers removed


parse
SELECT a, b FROM t
----
SELECT a, b FROM t
SELECT (a), (b) FROM t -- fully parenthesized
SELECT a, b FROM t -- literals removed
SELECT _, _ FROM _ -- identifiers removed

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

parse
SELECT 1 FROM t t1
----
SELECT 1 FROM t AS t1 -- normalized!
SELECT (1) FROM t AS t1 -- fully parenthesized
SELECT _ FROM t AS t1 -- literals removed
SELECT 1 FROM _ AS _ -- identifiers removed

parse
SELECT 1 FROM t t1 (c1, c2)
----
SELECT 1 FROM t AS t1 (c1, c2) -- normalized!
SELECT (1) FROM t AS t1 (c1, c2) -- fully parenthesized
SELECT _ FROM t AS t1 (c1, c2) -- literals removed
SELECT 1 FROM _ AS _ (_, _) -- identifiers removed


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

parse
SELECT a = b FROM t
----
SELECT a = b FROM t
SELECT ((a) = (b)) FROM t -- fully parenthesized
SELECT a = b FROM t -- literals removed
SELECT _ = _ FROM _ -- identifiers removed

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

parse
SELECT $1, $2 FROM t
----
SELECT $1, $2 FROM t
SELECT ($1), ($2) FROM t -- fully parenthesized
SELECT $1, $1 FROM t -- literals removed
SELECT $1, $2 FROM _ -- identifiers removed

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

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

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

parse
SELECT a.b FROM t
----
SELECT a.b FROM t
SELECT (a.b) FROM t -- fully parenthesized
SELECT a.b FROM t -- literals removed
SELECT _._ FROM _ -- identifiers removed

parse
SELECT a.b.* FROM t
----
SELECT a.b.* FROM t
SELECT (a.b.*) FROM t -- fully parenthesized
SELECT a.b.* FROM t -- literals removed
SELECT _._.* FROM _ -- identifiers removed

parse
SELECT a.b[1] FROM t
----
SELECT a.b[1] FROM t
SELECT ((a.b)[(1)]) FROM t -- fully parenthesized
SELECT a.b[_] FROM t -- literals removed
SELECT _._[1] FROM _ -- identifiers removed

parse
SELECT a.b[1 + 1:4][3] FROM t
----
SELECT a.b[1 + 1:4][3] FROM t
SELECT ((a.b)[((1) + (1)):(4)][(3)]) FROM t -- fully parenthesized
SELECT a.b[_ + _:_][_] FROM t -- literals removed
SELECT _._[1 + 1:4][3] FROM _ -- identifiers removed

parse
SELECT a.b[:4][3] FROM t
----
SELECT a.b[:4][3] FROM t
SELECT ((a.b)[:(4)][(3)]) FROM t -- fully parenthesized
SELECT a.b[:_][_] FROM t -- literals removed
SELECT _._[:4][3] FROM _ -- identifiers removed

parse
SELECT a.b[1 + 1:][3] FROM t
----
SELECT a.b[1 + 1:][3] FROM t
SELECT ((a.b)[((1) + (1)):][(3)]) FROM t -- fully parenthesized
SELECT a.b[_ + _:][_] FROM t -- literals removed
SELECT _._[1 + 1:][3] FROM _ -- identifiers removed

parse
SELECT a.b[:][3] FROM t
----
SELECT a.b[:][3] FROM t
SELECT ((a.b)[:][(3)]) FROM t -- fully parenthesized
SELECT a.b[:][_] FROM t -- literals removed
SELECT _._[:][3] FROM _ -- identifiers removed

parse
SELECT 'a' FROM t
----
SELECT 'a' FROM t
SELECT ('a') FROM t -- fully parenthesized
SELECT '_' FROM t -- literals removed
SELECT 'a' FROM _ -- identifiers removed

parse
SELECT * FROM t AS "of" AS OF SYSTEM TIME '2016-01-01'
----
SELECT * FROM t AS "of" AS OF SYSTEM TIME '2016-01-01'
SELECT (*) FROM t AS "of" AS OF SYSTEM TIME ('2016-01-01') -- fully parenthesized
SELECT * FROM t AS "of" AS OF SYSTEM TIME '_' -- literals removed
SELECT * FROM _ AS _ AS OF SYSTEM TIME '2016-01-01' -- identifiers removed

parse
SELECT a FROM t WHERE a <> b
----
SELECT a FROM t WHERE a != b -- normalized!
SELECT (a) FROM t WHERE ((a) != (b)) -- fully parenthesized
SELECT a FROM t WHERE a != b -- literals removed
SELECT _ FROM _ WHERE _ != _ -- identifiers removed

parse
SELECT a FROM t WHERE b = - 2
----
SELECT a FROM t WHERE b = -2 -- normalized!
SELECT (a) FROM t WHERE ((b) = (-2)) -- fully parenthesized
SELECT a FROM t WHERE b = _ -- literals removed
SELECT _ FROM _ WHERE _ = -2 -- identifiers removed

parse
SELECT a FROM t WHERE a = b AND a = c
----
SELECT a FROM t WHERE (a = b) AND (a = c) -- normalized!
SELECT (a) FROM t WHERE ((((a) = (b))) AND (((a) = (c)))) -- fully parenthesized
SELECT a FROM t WHERE (a = b) AND (a = c) -- literals removed
SELECT _ FROM _ WHERE (_ = _) AND (_ = _) -- identifiers removed

parse
SELECT a FROM t WHERE a = b OR a = c
----
SELECT a FROM t WHERE (a = b) OR (a = c) -- normalized!
SELECT (a) FROM t WHERE ((((a) = (b))) OR (((a) = (c)))) -- fully parenthesized
SELECT a FROM t WHERE (a = b) OR (a = c) -- literals removed
SELECT _ FROM _ WHERE (_ = _) OR (_ = _) -- identifiers removed

parse
SELECT a FROM t WHERE NOT a = b
----
SELECT a FROM t WHERE NOT (a = b) -- normalized!
SELECT (a) FROM t WHERE (NOT (((a) = (b)))) -- fully parenthesized
SELECT a FROM t WHERE NOT (a = b) -- literals removed
SELECT _ FROM _ WHERE NOT (_ = _) -- identifiers removed

parse
SELECT a FROM t WHERE a = b & c
----
SELECT a FROM t WHERE a = (b & c) -- normalized!
SELECT (a) FROM t WHERE ((a) = (((b) & (c)))) -- fully parenthesized
SELECT a FROM t WHERE a = (b & c) -- literals removed
SELECT _ FROM _ WHERE _ = (_ & _) -- identifiers removed

parse
SELECT a FROM t WHERE a = b | c
----
SELECT a FROM t WHERE a = (b | c) -- normalized!
SELECT (a) FROM t WHERE ((a) = (((b) | (c)))) -- fully parenthesized
SELECT a FROM t WHERE a = (b | c) -- literals removed
SELECT _ FROM _ WHERE _ = (_ | _) -- identifiers removed

parse
SELECT a FROM t WHERE a = b # c
----
SELECT a FROM t WHERE a = (b # c) -- normalized!
SELECT (a) FROM t WHERE ((a) = (((b) # (c)))) -- fully parenthesized
SELECT a FROM t WHERE a = (b # c) -- literals removed
SELECT _ FROM _ WHERE _ = (_ # _) -- identifiers removed

parse
SELECT a FROM t WHERE a = b ^ c
----
SELECT a FROM t WHERE a = (b ^ c) -- normalized!
SELECT (a) FROM t WHERE ((a) = (((b) ^ (c)))) -- fully parenthesized
SELECT a FROM t WHERE a = (b ^ c) -- literals removed
SELECT _ FROM _ WHERE _ = (_ ^ _) -- identifiers removed

parse
SELECT a FROM t WHERE a = b + c
----
SELECT a FROM t WHERE a = (b + c) -- normalized!
SELECT (a) FROM t WHERE ((a) = (((b) + (c)))) -- fully parenthesized
SELECT a FROM t WHERE a = (b + c) -- literals removed
SELECT _ FROM _ WHERE _ = (_ + _) -- identifiers removed

parse
SELECT a FROM t WHERE a = b - c
----
SELECT a FROM t WHERE a = (b - c) -- normalized!
SELECT (a) FROM t WHERE ((a) = (((b) - (c)))) -- fully parenthesized
SELECT a FROM t WHERE a = (b - c) -- literals removed
SELECT _ FROM _ WHERE _ = (_ - _) -- identifiers removed

parse
SELECT a FROM t WHERE a = b * c
----
SELECT a FROM t WHERE a = (b * c) -- normalized!
SELECT (a) FROM t WHERE ((a) = (((b) * (c)))) -- fully parenthesized
SELECT a FROM t WHERE a = (b * c) -- literals removed
SELECT _ FROM _ WHERE _ = (_ * _) -- identifiers removed

parse
SELECT a FROM t WHERE a = b / c
----
SELECT a FROM t WHERE a = (b / c) -- normalized!
SELECT (a) FROM t WHERE ((a) = (((b) / (c)))) -- fully parenthesized
SELECT a FROM t WHERE a = (b / c) -- literals removed
SELECT _ FROM _ WHERE _ = (_ / _) -- identifiers removed

parse
SELECT a FROM t WHERE a = b % c
----
SELECT a FROM t WHERE a = (b % c) -- normalized!
SELECT (a) FROM t WHERE ((a) = (((b) % (c)))) -- fully parenthesized
SELECT a FROM t WHERE a = (b % c) -- literals removed
SELECT _ FROM _ WHERE _ = (_ % _) -- identifiers removed

parse
SELECT a FROM t WHERE a = b || c
----
SELECT a FROM t WHERE a = (b || c) -- normalized!
SELECT (a) FROM t WHERE ((a) = (((b) || (c)))) -- fully parenthesized
SELECT a FROM t WHERE a = (b || c) -- literals removed
SELECT _ FROM _ WHERE _ = (_ || _) -- identifiers removed

parse
SELECT a FROM t WHERE a = + b
----
SELECT a FROM t WHERE a = b -- normalized!
SELECT (a) FROM t WHERE ((a) = (b)) -- fully parenthesized
SELECT a FROM t WHERE a = b -- literals removed
SELECT _ FROM _ WHERE _ = _ -- identifiers removed

parse
SELECT a FROM t WHERE a = - b
----
SELECT a FROM t WHERE a = (-b) -- normalized!
SELECT (a) FROM t WHERE ((a) = ((-(b)))) -- fully parenthesized
SELECT a FROM t WHERE a = (-b) -- literals removed
SELECT _ FROM _ WHERE _ = (-_) -- identifiers removed

parse
SELECT a FROM t WHERE a = ~ b
----
SELECT a FROM t WHERE a = (~b) -- normalized!
SELECT (a) FROM t WHERE ((a) = ((~(b)))) -- fully parenthesized
SELECT a FROM t WHERE a = (~b) -- literals removed
SELECT _ FROM _ WHERE _ = (~_) -- identifiers removed


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

parse
SELECT a FROM t AS bar (bar1)
----
SELECT a FROM t AS bar (bar1)
SELECT (a) FROM t AS bar (bar1) -- fully parenthesized
SELECT a FROM t AS bar (bar1) -- literals removed
SELECT _ FROM _ AS _ (_) -- identifiers removed

parse
SELECT a FROM t AS bar (bar1, bar2, bar3)
----
SELECT a FROM t AS bar (bar1, bar2, bar3)
SELECT (a) FROM t AS bar (bar1, bar2, bar3) -- fully parenthesized
SELECT a FROM t AS bar (bar1, bar2, bar3) -- literals removed
SELECT _ FROM _ AS _ (_, _, _) -- identifiers removed

parse
SELECT a FROM t WITH ORDINALITY
----
SELECT a FROM t WITH ORDINALITY
SELECT (a) FROM t WITH ORDINALITY -- fully parenthesized
SELECT a FROM t WITH ORDINALITY -- literals removed
SELECT _ FROM _ WITH ORDINALITY -- identifiers removed

parse
SELECT a FROM t WITH ORDINALITY AS bar
----
SELECT a FROM t WITH ORDINALITY AS bar
SELECT (a) FROM t WITH ORDINALITY AS bar -- fully parenthesized
SELECT a FROM t WITH ORDINALITY AS bar -- literals removed
SELECT _ FROM _ WITH ORDINALITY AS _ -- identifiers removed

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

parse
SELECT a FROM (SELECT 1 FROM t) AS bar
----
SELECT a FROM (SELECT 1 FROM t) AS bar
SELECT (a) FROM ((SELECT (1) FROM t)) AS bar -- fully parenthesized
SELECT a FROM (SELECT _ FROM t) AS bar -- literals removed
SELECT _ FROM (SELECT 1 FROM _) AS _ -- identifiers removed

parse
SELECT a FROM (SELECT 1 FROM t) AS bar (bar1)
----
SELECT a FROM (SELECT 1 FROM t) AS bar (bar1)
SELECT (a) FROM ((SELECT (1) FROM t)) AS bar (bar1) -- fully parenthesized
SELECT a FROM (SELECT _ FROM t) AS bar (bar1) -- literals removed
SELECT _ FROM (SELECT 1 FROM _) AS _ (_) -- identifiers removed

parse
SELECT a FROM (SELECT 1 FROM t) AS bar (bar1, bar2, bar3)
----
SELECT a FROM (SELECT 1 FROM t) AS bar (bar1, bar2, bar3)
SELECT (a) FROM ((SELECT (1) FROM t)) AS bar (bar1, bar2, bar3) -- fully parenthesized
SELECT a FROM (SELECT _ FROM t) AS bar (bar1, bar2, bar3) -- literals removed
SELECT _ FROM (SELECT 1 FROM _) AS _ (_, _, _) -- identifiers removed

parse
SELECT a FROM (SELECT 1 FROM t) WITH ORDINALITY
----
SELECT a FROM (SELECT 1 FROM t) WITH ORDINALITY
SELECT (a) FROM ((SELECT (1) FROM t)) WITH ORDINALITY -- fully parenthesized
SELECT a FROM (SELECT _ FROM t) WITH ORDINALITY -- literals removed
SELECT _ FROM (SELECT 1 FROM _) WITH ORDINALITY -- identifiers removed

parse
SELECT a FROM (SELECT 1 FROM t) WITH ORDINALITY AS bar
----
SELECT a FROM (SELECT 1 FROM t) WITH ORDINALITY AS bar
SELECT (a) FROM ((SELECT (1) FROM t)) WITH ORDINALITY AS bar -- fully parenthesized
SELECT a FROM (SELECT _ FROM t) WITH ORDINALITY AS bar -- literals removed
SELECT _ FROM (SELECT 1 FROM _) WITH ORDINALITY AS _ -- identifiers removed

parse
SELECT a FROM ROWS FROM (a(x), b(y), c(z))
----
SELECT a FROM ROWS FROM (a(x), b(y), c(z))
SELECT (a) FROM ROWS FROM ((a((x))), (b((y))), (c((z)))) -- fully parenthesized
SELECT a FROM ROWS FROM (a(x), b(y), c(z)) -- literals removed
SELECT _ FROM ROWS FROM (_(_), _(_), _(_)) -- identifiers removed

parse
SELECT a FROM generate_series(1, 32)
----
SELECT a FROM ROWS FROM (generate_series(1, 32)) -- normalized!
SELECT (a) FROM ROWS FROM ((generate_series((1), (32)))) -- fully parenthesized
SELECT a FROM ROWS FROM (generate_series(_, _)) -- literals removed
SELECT _ FROM ROWS FROM (_(1, 32)) -- identifiers removed

parse
SELECT a FROM generate_series(1, 32) AS s (x)
----
SELECT a FROM ROWS FROM (generate_series(1, 32)) AS s (x) -- normalized!
SELECT (a) FROM ROWS FROM ((generate_series((1), (32)))) AS s (x) -- fully parenthesized
SELECT a FROM ROWS FROM (generate_series(_, _)) AS s (x) -- literals removed
SELECT _ FROM ROWS FROM (_(1, 32)) AS _ (_) -- identifiers removed

parse
SELECT a FROM generate_series(1, 32) WITH ORDINALITY AS s (x)
----
SELECT a FROM ROWS FROM (generate_series(1, 32)) WITH ORDINALITY AS s (x) -- normalized!
SELECT (a) FROM ROWS FROM ((generate_series((1), (32)))) WITH ORDINALITY AS s (x) -- fully parenthesized
SELECT a FROM ROWS FROM (generate_series(_, _)) WITH ORDINALITY AS s (x) -- literals removed
SELECT _ FROM ROWS FROM (_(1, 32)) WITH ORDINALITY AS _ (_) -- identifiers removed


parse
SELECT a FROM t1, t2
----
SELECT a FROM t1, t2
SELECT (a) FROM t1, t2 -- fully parenthesized
SELECT a FROM t1, t2 -- literals removed
SELECT _ FROM _, _ -- identifiers removed

parse
SELECT a FROM t1, LATERAL (SELECT * FROM t2 WHERE a = b)
----
SELECT a FROM t1, LATERAL (SELECT * FROM t2 WHERE a = b)
SELECT (a) FROM t1, LATERAL ((SELECT (*) FROM t2 WHERE ((a) = (b)))) -- fully parenthesized
SELECT a FROM t1, LATERAL (SELECT * FROM t2 WHERE a = b) -- literals removed
SELECT _ FROM _, LATERAL (SELECT * FROM _ WHERE _ = _) -- identifiers removed

parse
SELECT a FROM t1, LATERAL ROWS FROM (generate_series(1, t1.x))
----
SELECT a FROM t1, LATERAL ROWS FROM (generate_series(1, t1.x))
SELECT (a) FROM t1, LATERAL ROWS FROM ((generate_series((1), (t1.x)))) -- fully parenthesized
SELECT a FROM t1, LATERAL ROWS FROM (generate_series(_, t1.x)) -- literals removed
SELECT _ FROM _, LATERAL ROWS FROM (_(1, _._)) -- identifiers removed

parse
SELECT a FROM LATERAL generate_series(1, 32)
----
SELECT a FROM LATERAL ROWS FROM (generate_series(1, 32)) -- normalized!
SELECT (a) FROM LATERAL ROWS FROM ((generate_series((1), (32)))) -- fully parenthesized
SELECT a FROM LATERAL ROWS FROM (generate_series(_, _)) -- literals removed
SELECT _ FROM LATERAL ROWS FROM (_(1, 32)) -- identifiers removed


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

parse
SELECT a FROM t AS t1 (c1)
----
SELECT a FROM t AS t1 (c1)
SELECT (a) FROM t AS t1 (c1) -- fully parenthesized
SELECT a FROM t AS t1 (c1) -- literals removed
SELECT _ FROM _ AS _ (_) -- identifiers removed

parse
SELECT a FROM t AS t1 (c1, c2, c3, c4)
----
SELECT a FROM t AS t1 (c1, c2, c3, c4)
SELECT (a) FROM t AS t1 (c1, c2, c3, c4) -- fully parenthesized
SELECT a FROM t AS t1 (c1, c2, c3, c4) -- literals removed
SELECT _ FROM _ AS _ (_, _, _, _) -- identifiers removed

parse
SELECT a FROM s.t
----
SELECT a FROM s.t
SELECT (a) FROM s.t -- fully parenthesized
SELECT a FROM s.t -- literals removed
SELECT _ FROM _._ -- identifiers removed

parse
SELECT count(DISTINCT a) FROM t
----
SELECT count(DISTINCT a) FROM t
SELECT (count(DISTINCT (a))) FROM t -- fully parenthesized
SELECT count(DISTINCT a) FROM t -- literals removed
SELECT _(DISTINCT _) FROM _ -- identifiers removed

parse
SELECT count(ALL a) FROM t
----
SELECT count(ALL a) FROM t
SELECT (count(ALL (a))) FROM t -- fully parenthesized
SELECT count(ALL a) FROM t -- literals removed
SELECT _(ALL _) FROM _ -- identifiers removed

parse
SELECT a FROM t WHERE a = b
----
SELECT a FROM t WHERE a = b
SELECT (a) FROM t WHERE ((a) = (b)) -- fully parenthesized
SELECT a FROM t WHERE a = b -- literals removed
SELECT _ FROM _ WHERE _ = _ -- identifiers removed

parse
SELECT a FROM t WHERE NOT (a = b)
----
SELECT a FROM t WHERE NOT (a = b)
SELECT (a) FROM t WHERE (NOT ((((a) = (b))))) -- fully parenthesized
SELECT a FROM t WHERE NOT (a = b) -- literals removed
SELECT _ FROM _ WHERE NOT (_ = _) -- identifiers removed

parse
SELECT a FROM t WHERE EXISTS (SELECT 1 FROM t)
----
SELECT a FROM t WHERE EXISTS (SELECT 1 FROM t)
SELECT (a) FROM t WHERE (EXISTS (SELECT (1) FROM t)) -- fully parenthesized
SELECT a FROM t WHERE EXISTS (SELECT _ FROM t) -- literals removed
SELECT _ FROM _ WHERE EXISTS (SELECT 1 FROM _) -- identifiers removed

parse
SELECT a FROM t WHERE NOT true
----
SELECT a FROM t WHERE NOT true
SELECT (a) FROM t WHERE (NOT (true)) -- fully parenthesized
SELECT a FROM t WHERE NOT _ -- literals removed
SELECT _ FROM _ WHERE NOT true -- identifiers removed

parse
SELECT a FROM t WHERE NOT false
----
SELECT a FROM t WHERE NOT false
SELECT (a) FROM t WHERE (NOT (false)) -- fully parenthesized
SELECT a FROM t WHERE NOT _ -- literals removed
SELECT _ FROM _ WHERE NOT false -- identifiers removed

parse
SELECT a FROM t WHERE a IN (b,)
----
SELECT a FROM t WHERE a IN (b,)
SELECT (a) FROM t WHERE ((a) IN (((b),))) -- fully parenthesized
SELECT a FROM t WHERE a IN (b,) -- literals removed
SELECT _ FROM _ WHERE _ IN (_,) -- identifiers removed

parse
SELECT a FROM t WHERE a IN (b, c)
----
SELECT a FROM t WHERE a IN (b, c)
SELECT (a) FROM t WHERE ((a) IN (((b), (c)))) -- fully parenthesized
SELECT a FROM t WHERE a IN (b, c) -- literals removed
SELECT _ FROM _ WHERE _ IN (_, _) -- identifiers removed

parse
SELECT a FROM t WHERE a IN (SELECT a FROM t)
----
SELECT a FROM t WHERE a IN (SELECT a FROM t)
SELECT (a) FROM t WHERE ((a) IN ((SELECT (a) FROM t))) -- fully parenthesized
SELECT a FROM t WHERE a IN (SELECT a FROM t) -- literals removed
SELECT _ FROM _ WHERE _ IN (SELECT _ FROM _) -- identifiers removed

parse
SELECT a FROM t WHERE a NOT IN (b, c)
----
SELECT a FROM t WHERE a NOT IN (b, c)
SELECT (a) FROM t WHERE ((a) NOT IN (((b), (c)))) -- fully parenthesized
SELECT a FROM t WHERE a NOT IN (b, c) -- literals removed
SELECT _ FROM _ WHERE _ NOT IN (_, _) -- identifiers removed

parse
SELECT a FROM t WHERE a = ANY (ARRAY[b, c])
----
SELECT a FROM t WHERE a = ANY (ARRAY[b, c])
SELECT (a) FROM t WHERE ((a) = ANY (((ARRAY[(b), (c)])))) -- fully parenthesized
SELECT a FROM t WHERE a = ANY (ARRAY[b, c]) -- literals removed
SELECT _ FROM _ WHERE _ = ANY (ARRAY[_, _]) -- identifiers removed

parse
SELECT a FROM t WHERE a = ANY ARRAY[b, c]
----
SELECT a FROM t WHERE a = ANY ARRAY[b, c]
SELECT (a) FROM t WHERE ((a) = ANY (ARRAY[(b), (c)])) -- fully parenthesized
SELECT a FROM t WHERE a = ANY ARRAY[b, c] -- literals removed
SELECT _ FROM _ WHERE _ = ANY ARRAY[_, _] -- identifiers removed

parse
SELECT a FROM t WHERE a != SOME (ARRAY[b, c])
----
SELECT a FROM t WHERE a != SOME (ARRAY[b, c])
SELECT (a) FROM t WHERE ((a) != SOME (((ARRAY[(b), (c)])))) -- fully parenthesized
SELECT a FROM t WHERE a != SOME (ARRAY[b, c]) -- literals removed
SELECT _ FROM _ WHERE _ != SOME (ARRAY[_, _]) -- identifiers removed

parse
SELECT a FROM t WHERE a != SOME ARRAY[b, c]
----
SELECT a FROM t WHERE a != SOME ARRAY[b, c]
SELECT (a) FROM t WHERE ((a) != SOME (ARRAY[(b), (c)])) -- fully parenthesized
SELECT a FROM t WHERE a != SOME ARRAY[b, c] -- literals removed
SELECT _ FROM _ WHERE _ != SOME ARRAY[_, _] -- identifiers removed

parse
SELECT a FROM t WHERE a = ANY (SELECT 1)
----
SELECT a FROM t WHERE a = ANY (SELECT 1)
SELECT (a) FROM t WHERE ((a) = ANY ((SELECT (1)))) -- fully parenthesized
SELECT a FROM t WHERE a = ANY (SELECT _) -- literals removed
SELECT _ FROM _ WHERE _ = ANY (SELECT 1) -- identifiers removed

parse
SELECT a FROM t WHERE a LIKE ALL (ARRAY[b, c])
----
SELECT a FROM t WHERE a LIKE ALL (ARRAY[b, c])
SELECT (a) FROM t WHERE ((a) LIKE ALL (((ARRAY[(b), (c)])))) -- fully parenthesized
SELECT a FROM t WHERE a LIKE ALL (ARRAY[b, c]) -- literals removed
SELECT _ FROM _ WHERE _ LIKE ALL (ARRAY[_, _]) -- identifiers removed

parse
SELECT a FROM t WHERE a LIKE ALL ARRAY[b, c]
----
SELECT a FROM t WHERE a LIKE ALL ARRAY[b, c]
SELECT (a) FROM t WHERE ((a) LIKE ALL (ARRAY[(b), (c)])) -- fully parenthesized
SELECT a FROM t WHERE a LIKE ALL ARRAY[b, c] -- literals removed
SELECT _ FROM _ WHERE _ LIKE ALL ARRAY[_, _] -- identifiers removed

parse
SELECT a FROM t WHERE a LIKE b
----
SELECT a FROM t WHERE a LIKE b
SELECT (a) FROM t WHERE ((a) LIKE (b)) -- fully parenthesized
SELECT a FROM t WHERE a LIKE b -- literals removed
SELECT _ FROM _ WHERE _ LIKE _ -- identifiers removed

parse
SELECT a FROM t WHERE a NOT LIKE b
----
SELECT a FROM t WHERE a NOT LIKE b
SELECT (a) FROM t WHERE ((a) NOT LIKE (b)) -- fully parenthesized
SELECT a FROM t WHERE a NOT LIKE b -- literals removed
SELECT _ FROM _ WHERE _ NOT LIKE _ -- identifiers removed

parse
SELECT a FROM t WHERE a ILIKE b
----
SELECT a FROM t WHERE a ILIKE b
SELECT (a) FROM t WHERE ((a) ILIKE (b)) -- fully parenthesized
SELECT a FROM t WHERE a ILIKE b -- literals removed
SELECT _ FROM _ WHERE _ ILIKE _ -- identifiers removed

parse
SELECT a FROM t WHERE a NOT ILIKE b
----
SELECT a FROM t WHERE a NOT ILIKE b
SELECT (a) FROM t WHERE ((a) NOT ILIKE (b)) -- fully parenthesized
SELECT a FROM t WHERE a NOT ILIKE b -- literals removed
SELECT _ FROM _ WHERE _ NOT ILIKE _ -- identifiers removed

parse
SELECT a FROM t WHERE a SIMILAR TO b
----
SELECT a FROM t WHERE a SIMILAR TO b
SELECT (a) FROM t WHERE ((a) SIMILAR TO (b)) -- fully parenthesized
SELECT a FROM t WHERE a SIMILAR TO b -- literals removed
SELECT _ FROM _ WHERE _ SIMILAR TO _ -- identifiers removed

parse
SELECT a FROM t WHERE a NOT SIMILAR TO b
----
SELECT a FROM t WHERE a NOT SIMILAR TO b
SELECT (a) FROM t WHERE ((a) NOT SIMILAR TO (b)) -- fully parenthesized
SELECT a FROM t WHERE a NOT SIMILAR TO b -- literals removed
SELECT _ FROM _ WHERE _ NOT SIMILAR TO _ -- identifiers removed

parse
SELECT a FROM t WHERE a ~ b
----
SELECT a FROM t WHERE a ~ b
SELECT (a) FROM t WHERE ((a) ~ (b)) -- fully parenthesized
SELECT a FROM t WHERE a ~ b -- literals removed
SELECT _ FROM _ WHERE _ ~ _ -- identifiers removed

parse
SELECT a FROM t WHERE a !~ b
----
SELECT a FROM t WHERE a !~ b
SELECT (a) FROM t WHERE ((a) !~ (b)) -- fully parenthesized
SELECT a FROM t WHERE a !~ b -- literals removed
SELECT _ FROM _ WHERE _ !~ _ -- identifiers removed

parse
SELECT a FROM t WHERE a ~* c
----
SELECT a FROM t WHERE a ~* c
SELECT (a) FROM t WHERE ((a) ~* (c)) -- fully parenthesized
SELECT a FROM t WHERE a ~* c -- literals removed
SELECT _ FROM _ WHERE _ ~* _ -- identifiers removed

parse
SELECT a FROM t WHERE a !~* c
----
SELECT a FROM t WHERE a !~* c
SELECT (a) FROM t WHERE ((a) !~* (c)) -- fully parenthesized
SELECT a FROM t WHERE a !~* c -- literals removed
SELECT _ FROM _ WHERE _ !~* _ -- identifiers removed

parse
SELECT a FROM t WHERE a BETWEEN b AND c
----
SELECT a FROM t WHERE a BETWEEN b AND c
SELECT (a) FROM t WHERE ((a) BETWEEN (b) AND (c)) -- fully parenthesized
SELECT a FROM t WHERE a BETWEEN b AND c -- literals removed
SELECT _ FROM _ WHERE _ BETWEEN _ AND _ -- identifiers removed

parse
SELECT a FROM t WHERE a BETWEEN SYMMETRIC b AND c
----
SELECT a FROM t WHERE a BETWEEN SYMMETRIC b AND c
SELECT (a) FROM t WHERE ((a) BETWEEN SYMMETRIC (b) AND (c)) -- fully parenthesized
SELECT a FROM t WHERE a BETWEEN SYMMETRIC b AND c -- literals removed
SELECT _ FROM _ WHERE _ BETWEEN SYMMETRIC _ AND _ -- identifiers removed

parse
SELECT a FROM t WHERE a NOT BETWEEN b AND c
----
SELECT a FROM t WHERE a NOT BETWEEN b AND c
SELECT (a) FROM t WHERE ((a) NOT BETWEEN (b) AND (c)) -- fully parenthesized
SELECT a FROM t WHERE a NOT BETWEEN b AND c -- literals removed
SELECT _ FROM _ WHERE _ NOT BETWEEN _ AND _ -- identifiers removed

parse
SELECT a FROM t WHERE a NOT BETWEEN SYMMETRIC b AND c
----
SELECT a FROM t WHERE a NOT BETWEEN SYMMETRIC b AND c
SELECT (a) FROM t WHERE ((a) NOT BETWEEN SYMMETRIC (b) AND (c)) -- fully parenthesized
SELECT a FROM t WHERE a NOT BETWEEN SYMMETRIC b AND c -- literals removed
SELECT _ FROM _ WHERE _ NOT BETWEEN SYMMETRIC _ AND _ -- identifiers removed

parse
SELECT a FROM t WHERE a BETWEEN ASYMMETRIC b AND c
----
SELECT a FROM t WHERE a BETWEEN b AND c -- normalized!
SELECT (a) FROM t WHERE ((a) BETWEEN (b) AND (c)) -- fully parenthesized
SELECT a FROM t WHERE a BETWEEN b AND c -- literals removed
SELECT _ FROM _ WHERE _ BETWEEN _ AND _ -- identifiers removed


parse
SELECT a FROM t WHERE a IS NULL
----
SELECT a FROM t WHERE a IS NULL
SELECT (a) FROM t WHERE ((a) IS NULL) -- fully parenthesized
SELECT a FROM t WHERE a IS NULL -- literals removed
SELECT _ FROM _ WHERE _ IS NULL -- identifiers removed

parse
SELECT a FROM t WHERE a IS NOT NULL
----
SELECT a FROM t WHERE a IS NOT NULL
SELECT (a) FROM t WHERE ((a) IS NOT NULL) -- fully parenthesized
SELECT a FROM t WHERE a IS NOT NULL -- literals removed
SELECT _ FROM _ WHERE _ IS NOT NULL -- identifiers removed

parse
SELECT a FROM t WHERE (a, b) IS NULL
----
SELECT a FROM t WHERE (a, b) IS NULL
SELECT (a) FROM t WHERE ((((a), (b))) IS NULL) -- fully parenthesized
SELECT a FROM t WHERE (a, b) IS NULL -- literals removed
SELECT _ FROM _ WHERE (_, _) IS NULL -- identifiers removed

parse
SELECT a FROM t WHERE (a, b) IS NOT NULL
----
SELECT a FROM t WHERE (a, b) IS NOT NULL
SELECT (a) FROM t WHERE ((((a), (b))) IS NOT NULL) -- fully parenthesized
SELECT a FROM t WHERE (a, b) IS NOT NULL -- literals removed
SELECT _ FROM _ WHERE (_, _) IS NOT NULL -- identifiers removed

parse
SELECT a FROM t WHERE a ISNULL
----
SELECT a FROM t WHERE a IS NULL -- normalized!
SELECT (a) FROM t WHERE ((a) IS NULL) -- fully parenthesized
SELECT a FROM t WHERE a IS NULL -- literals removed
SELECT _ FROM _ WHERE _ IS NULL -- identifiers removed

parse
SELECT a FROM t WHERE a NOTNULL
----
SELECT a FROM t WHERE a IS NOT NULL -- normalized!
SELECT (a) FROM t WHERE ((a) IS NOT NULL) -- fully parenthesized
SELECT a FROM t WHERE a IS NOT NULL -- literals removed
SELECT _ FROM _ WHERE _ IS NOT NULL -- identifiers removed

parse
SELECT a FROM t WHERE a IS UNKNOWN
----
SELECT a FROM t WHERE a IS NOT DISTINCT FROM NULL -- normalized!
SELECT (a) FROM t WHERE ((a) IS NOT DISTINCT FROM (NULL)) -- fully parenthesized
SELECT a FROM t WHERE a IS NOT DISTINCT FROM _ -- literals removed
SELECT _ FROM _ WHERE _ IS NOT DISTINCT FROM NULL -- identifiers removed

parse
SELECT a FROM t WHERE a IS NOT UNKNOWN
----
SELECT a FROM t WHERE a IS DISTINCT FROM NULL -- normalized!
SELECT (a) FROM t WHERE ((a) IS DISTINCT FROM (NULL)) -- fully parenthesized
SELECT a FROM t WHERE a IS DISTINCT FROM _ -- literals removed
SELECT _ FROM _ WHERE _ IS DISTINCT FROM NULL -- identifiers removed

parse
SELECT a FROM t WHERE a IS true
----
SELECT a FROM t WHERE a IS true
SELECT (a) FROM t WHERE ((a) IS (true)) -- fully parenthesized
SELECT a FROM t WHERE a IS NOT DISTINCT FROM _ -- literals removed
SELECT _ FROM _ WHERE _ IS true -- identifiers removed

parse
SELECT a FROM t WHERE a IS NOT true
----
SELECT a FROM t WHERE a IS NOT true
SELECT (a) FROM t WHERE ((a) IS NOT (true)) -- fully parenthesized
SELECT a FROM t WHERE a IS DISTINCT FROM _ -- literals removed
SELECT _ FROM _ WHERE _ IS NOT true -- identifiers removed

parse
SELECT a FROM t WHERE a IS false
----
SELECT a FROM t WHERE a IS false
SELECT (a) FROM t WHERE ((a) IS (false)) -- fully parenthesized
SELECT a FROM t WHERE a IS NOT DISTINCT FROM _ -- literals removed
SELECT _ FROM _ WHERE _ IS false -- identifiers removed

parse
SELECT a FROM t WHERE a IS NOT false
----
SELECT a FROM t WHERE a IS NOT false
SELECT (a) FROM t WHERE ((a) IS NOT (false)) -- fully parenthesized
SELECT a FROM t WHERE a IS DISTINCT FROM _ -- literals removed
SELECT _ FROM _ WHERE _ IS NOT false -- identifiers removed

parse
SELECT a FROM t WHERE a IS OF (INT8)
----
SELECT a FROM t WHERE a IS OF (INT8)
SELECT (a) FROM t WHERE ((a) IS OF (INT8)) -- fully parenthesized
SELECT a FROM t WHERE a IS OF (INT8) -- literals removed
SELECT _ FROM _ WHERE _ IS OF (INT8) -- identifiers removed

parse
SELECT a FROM t WHERE a IS NOT OF (FLOAT8, STRING)
----
SELECT a FROM t WHERE a IS NOT OF (FLOAT8, STRING)
SELECT (a) FROM t WHERE ((a) IS NOT OF (FLOAT8, STRING)) -- fully parenthesized
SELECT a FROM t WHERE a IS NOT OF (FLOAT8, STRING) -- literals removed
SELECT _ FROM _ WHERE _ IS NOT OF (FLOAT8, STRING) -- identifiers removed

parse
SELECT a FROM t WHERE a IS DISTINCT FROM b
----
SELECT a FROM t WHERE a IS DISTINCT FROM b
SELECT (a) FROM t WHERE ((a) IS DISTINCT FROM (b)) -- fully parenthesized
SELECT a FROM t WHERE a IS DISTINCT FROM b -- literals removed
SELECT _ FROM _ WHERE _ IS DISTINCT FROM _ -- identifiers removed

parse
SELECT a FROM t WHERE a IS NOT DISTINCT FROM b
----
SELECT a FROM t WHERE a IS NOT DISTINCT FROM b
SELECT (a) FROM t WHERE ((a) IS NOT DISTINCT FROM (b)) -- fully parenthesized
SELECT a FROM t WHERE a IS NOT DISTINCT FROM b -- literals removed
SELECT _ FROM _ WHERE _ IS NOT DISTINCT FROM _ -- identifiers removed

parse
SELECT a FROM t WHERE (a, b) IS NOT DISTINCT FROM NULL
----
SELECT a FROM t WHERE (a, b) IS NOT DISTINCT FROM NULL
SELECT (a) FROM t WHERE ((((a), (b))) IS NOT DISTINCT FROM (NULL)) -- fully parenthesized
SELECT a FROM t WHERE (a, b) IS NOT DISTINCT FROM _ -- literals removed
SELECT _ FROM _ WHERE (_, _) IS NOT DISTINCT FROM NULL -- identifiers removed

parse
SELECT a FROM t WHERE (a, b) IS DISTINCT FROM NULL
----
SELECT a FROM t WHERE (a, b) IS DISTINCT FROM NULL
SELECT (a) FROM t WHERE ((((a), (b))) IS DISTINCT FROM (NULL)) -- fully parenthesized
SELECT a FROM t WHERE (a, b) IS DISTINCT FROM _ -- literals removed
SELECT _ FROM _ WHERE (_, _) IS DISTINCT FROM NULL -- identifiers removed

parse
SELECT a FROM t WHERE a < b
----
SELECT a FROM t WHERE a < b
SELECT (a) FROM t WHERE ((a) < (b)) -- fully parenthesized
SELECT a FROM t WHERE a < b -- literals removed
SELECT _ FROM _ WHERE _ < _ -- identifiers removed

parse
SELECT a FROM t WHERE a <= b
----
SELECT a FROM t WHERE a <= b
SELECT (a) FROM t WHERE ((a) <= (b)) -- fully parenthesized
SELECT a FROM t WHERE a <= b -- literals removed
SELECT _ FROM _ WHERE _ <= _ -- identifiers removed

parse
SELECT a FROM t WHERE a >= b
----
SELECT a FROM t WHERE a >= b
SELECT (a) FROM t WHERE ((a) >= (b)) -- fully parenthesized
SELECT a FROM t WHERE a >= b -- literals removed
SELECT _ FROM _ WHERE _ >= _ -- identifiers removed

parse
SELECT a FROM t WHERE a != b
----
SELECT a FROM t WHERE a != b
SELECT (a) FROM t WHERE ((a) != (b)) -- fully parenthesized
SELECT a FROM t WHERE a != b -- literals removed
SELECT _ FROM _ WHERE _ != _ -- identifiers removed

parse
SELECT a FROM t WHERE a = (SELECT a FROM t)
----
SELECT a FROM t WHERE a = (SELECT a FROM t)
SELECT (a) FROM t WHERE ((a) = ((SELECT (a) FROM t))) -- fully parenthesized
SELECT a FROM t WHERE a = (SELECT a FROM t) -- literals removed
SELECT _ FROM _ WHERE _ = (SELECT _ FROM _) -- identifiers removed

parse
SELECT a FROM t WHERE a = (b)
----
SELECT a FROM t WHERE a = (b)
SELECT (a) FROM t WHERE ((a) = (((b)))) -- fully parenthesized
SELECT a FROM t WHERE a = (b) -- literals removed
SELECT _ FROM _ WHERE _ = (_) -- identifiers removed

parse
SELECT a FROM t WHERE CASE WHEN a = b THEN c END
----
SELECT a FROM t WHERE CASE WHEN a = b THEN c END
SELECT (a) FROM t WHERE (CASE WHEN ((a) = (b)) THEN (c) END) -- fully parenthesized
SELECT a FROM t WHERE CASE WHEN a = b THEN c END -- literals removed
SELECT _ FROM _ WHERE CASE WHEN _ = _ THEN _ END -- identifiers removed

parse
SELECT a FROM t WHERE CASE WHEN a = b THEN c ELSE d END
----
SELECT a FROM t WHERE CASE WHEN a = b THEN c ELSE d END
SELECT (a) FROM t WHERE (CASE WHEN ((a) = (b)) THEN (c) ELSE (d) END) -- fully parenthesized
SELECT a FROM t WHERE CASE WHEN a = b THEN c ELSE d END -- literals removed
SELECT _ FROM _ WHERE CASE WHEN _ = _ THEN _ ELSE _ END -- identifiers removed

parse
SELECT a FROM t WHERE CASE WHEN a = b THEN c WHEN b = d THEN d ELSE d END
----
SELECT a FROM t WHERE CASE WHEN a = b THEN c WHEN b = d THEN d ELSE d END
SELECT (a) FROM t WHERE (CASE WHEN ((a) = (b)) THEN (c) WHEN ((b) = (d)) THEN (d) ELSE (d) END) -- fully parenthesized
SELECT a FROM t WHERE CASE WHEN a = b THEN c WHEN b = d THEN d ELSE d END -- literals removed
SELECT _ FROM _ WHERE CASE WHEN _ = _ THEN _ WHEN _ = _ THEN _ ELSE _ END -- identifiers removed

parse
SELECT a FROM t WHERE CASE aa WHEN a = b THEN c END
----
SELECT a FROM t WHERE CASE aa WHEN a = b THEN c END
SELECT (a) FROM t WHERE (CASE (aa) WHEN ((a) = (b)) THEN (c) END) -- fully parenthesized
SELECT a FROM t WHERE CASE aa WHEN a = b THEN c END -- literals removed
SELECT _ FROM _ WHERE CASE _ WHEN _ = _ THEN _ END -- identifiers removed

parse
SELECT a FROM t WHERE a = b()
----
SELECT a FROM t WHERE a = b()
SELECT (a) FROM t WHERE ((a) = (b())) -- fully parenthesized
SELECT a FROM t WHERE a = b() -- literals removed
SELECT _ FROM _ WHERE _ = _() -- identifiers removed

parse
SELECT a FROM t WHERE a = b(c)
----
SELECT a FROM t WHERE a = b(c)
SELECT (a) FROM t WHERE ((a) = (b((c)))) -- fully parenthesized
SELECT a FROM t WHERE a = b(c) -- literals removed
SELECT _ FROM _ WHERE _ = _(_) -- identifiers removed

parse
SELECT a FROM t WHERE a = b(c, d)
----
SELECT a FROM t WHERE a = b(c, d)
SELECT (a) FROM t WHERE ((a) = (b((c), (d)))) -- fully parenthesized
SELECT a FROM t WHERE a = b(c, d) -- literals removed
SELECT _ FROM _ WHERE _ = _(_, _) -- identifiers removed

parse
SELECT a FROM t WHERE a = count(*)
----
SELECT a FROM t WHERE a = count(*)
SELECT (a) FROM t WHERE ((a) = (count((*)))) -- fully parenthesized
SELECT a FROM t WHERE a = count(*) -- literals removed
SELECT _ FROM _ WHERE _ = _(*) -- identifiers removed

parse
SELECT a FROM t WHERE a = IF(b, c, d)
----
SELECT a FROM t WHERE a = IF(b, c, d)
SELECT (a) FROM t WHERE ((a) = (IF((b), (c), (d)))) -- fully parenthesized
SELECT a FROM t WHERE a = IF(b, c, d) -- literals removed
SELECT _ FROM _ WHERE _ = IF(_, _, _) -- identifiers removed

parse
SELECT a FROM t WHERE a = IFERROR(b, c, d)
----
SELECT a FROM t WHERE a = IFERROR(b, c, d)
SELECT (a) FROM t WHERE ((a) = (IFERROR((b), (c), (d)))) -- fully parenthesized
SELECT a FROM t WHERE a = IFERROR(b, c, d) -- literals removed
SELECT _ FROM _ WHERE _ = IFERROR(_, _, _) -- identifiers removed

parse
SELECT a FROM t WHERE a = IFERROR(b, c)
----
SELECT a FROM t WHERE a = IFERROR(b, c)
SELECT (a) FROM t WHERE ((a) = (IFERROR((b), (c)))) -- fully parenthesized
SELECT a FROM t WHERE a = IFERROR(b, c) -- literals removed
SELECT _ FROM _ WHERE _ = IFERROR(_, _) -- identifiers removed

parse
SELECT a FROM t WHERE a = ISERROR(b)
----
SELECT a FROM t WHERE a = ISERROR(b)
SELECT (a) FROM t WHERE ((a) = (ISERROR((b)))) -- fully parenthesized
SELECT a FROM t WHERE a = ISERROR(b) -- literals removed
SELECT _ FROM _ WHERE _ = ISERROR(_) -- identifiers removed

parse
SELECT a FROM t WHERE a = ISERROR(b, c)
----
SELECT a FROM t WHERE a = ISERROR(b, c)
SELECT (a) FROM t WHERE ((a) = (ISERROR((b), (c)))) -- fully parenthesized
SELECT a FROM t WHERE a = ISERROR(b, c) -- literals removed
SELECT _ FROM _ WHERE _ = ISERROR(_, _) -- identifiers removed

parse
SELECT a FROM t WHERE a = IFNULL(b, c)
----
SELECT a FROM t WHERE a = IFNULL(b, c)
SELECT (a) FROM t WHERE ((a) = (IFNULL((b), (c)))) -- fully parenthesized
SELECT a FROM t WHERE a = IFNULL(b, c) -- literals removed
SELECT _ FROM _ WHERE _ = IFNULL(_, _) -- identifiers removed

parse
SELECT a FROM t WHERE a = NULLIF(b, c)
----
SELECT a FROM t WHERE a = NULLIF(b, c)
SELECT (a) FROM t WHERE ((a) = (NULLIF((b), (c)))) -- fully parenthesized
SELECT a FROM t WHERE a = NULLIF(b, c) -- literals removed
SELECT _ FROM _ WHERE _ = NULLIF(_, _) -- identifiers removed

parse
SELECT a FROM t WHERE a = COALESCE(a, b, c, d, e)
----
SELECT a FROM t WHERE a = COALESCE(a, b, c, d, e)
SELECT (a) FROM t WHERE ((a) = (COALESCE((a), (b), (c), (d), (e)))) -- fully parenthesized
SELECT a FROM t WHERE a = COALESCE(a, b, c, d, e) -- literals removed
SELECT _ FROM _ WHERE _ = COALESCE(_, _, _, _, _) -- identifiers removed

parse
SELECT (a.b) FROM t WHERE (b.c) = 2
----
SELECT (a.b) FROM t WHERE (b.c) = 2
SELECT (((a.b))) FROM t WHERE ((((b.c))) = (2)) -- fully parenthesized
SELECT (a.b) FROM t WHERE (b.c) = _ -- literals removed
SELECT (_._) FROM _ WHERE (_._) = 2 -- identifiers removed

error
SELECT * FROM t WHERE k=
----
at or near "EOF": syntax error
DETAIL: source SQL:
SELECT * FROM t WHERE k=
                        ^

parse
SELECT a FROM t ORDER BY a
----
SELECT a FROM t ORDER BY a
SELECT (a) FROM t ORDER BY (a) -- fully parenthesized
SELECT a FROM t ORDER BY a -- literals removed
SELECT _ FROM _ ORDER BY _ -- identifiers removed

parse
SELECT a FROM t ORDER BY a ASC
----
SELECT a FROM t ORDER BY a ASC
SELECT (a) FROM t ORDER BY (a) ASC -- fully parenthesized
SELECT a FROM t ORDER BY a ASC -- literals removed
SELECT _ FROM _ ORDER BY _ ASC -- identifiers removed

parse
SELECT a FROM t ORDER BY a DESC
----
SELECT a FROM t ORDER BY a DESC
SELECT (a) FROM t ORDER BY (a) DESC -- fully parenthesized
SELECT a FROM t ORDER BY a DESC -- literals removed
SELECT _ FROM _ ORDER BY _ DESC -- identifiers removed

parse
SELECT a FROM t ORDER BY PRIMARY KEY t
----
SELECT a FROM t ORDER BY PRIMARY KEY t
SELECT (a) FROM t ORDER BY PRIMARY KEY t -- fully parenthesized
SELECT a FROM t ORDER BY PRIMARY KEY t -- literals removed
SELECT _ FROM _ ORDER BY PRIMARY KEY _ -- identifiers removed

parse
SELECT a FROM t ORDER BY PRIMARY KEY t ASC
----
SELECT a FROM t ORDER BY PRIMARY KEY t ASC
SELECT (a) FROM t ORDER BY PRIMARY KEY t ASC -- fully parenthesized
SELECT a FROM t ORDER BY PRIMARY KEY t ASC -- literals removed
SELECT _ FROM _ ORDER BY PRIMARY KEY _ ASC -- identifiers removed

parse
SELECT a FROM t ORDER BY PRIMARY KEY t DESC
----
SELECT a FROM t ORDER BY PRIMARY KEY t DESC
SELECT (a) FROM t ORDER BY PRIMARY KEY t DESC -- fully parenthesized
SELECT a FROM t ORDER BY PRIMARY KEY t DESC -- literals removed
SELECT _ FROM _ ORDER BY PRIMARY KEY _ DESC -- identifiers removed

parse
SELECT a FROM t ORDER BY INDEX t@foo
----
SELECT a FROM t ORDER BY INDEX t@foo
SELECT (a) FROM t ORDER BY INDEX t@foo -- fully parenthesized
SELECT a FROM t ORDER BY INDEX t@foo -- literals removed
SELECT _ FROM _ ORDER BY INDEX _@_ -- identifiers removed

parse
SELECT a FROM t ORDER BY INDEX t.t.t@foo
----
SELECT a FROM t ORDER BY INDEX t.t.t@foo
SELECT (a) FROM t ORDER BY INDEX t.t.t@foo -- fully parenthesized
SELECT a FROM t ORDER BY INDEX t.t.t@foo -- literals removed
SELECT _ FROM _ ORDER BY INDEX _._._@_ -- identifiers removed

parse
SELECT a FROM t ORDER BY INDEX t@foo ASC
----
SELECT a FROM t ORDER BY INDEX t@foo ASC
SELECT (a) FROM t ORDER BY INDEX t@foo ASC -- fully parenthesized
SELECT a FROM t ORDER BY INDEX t@foo ASC -- literals removed
SELECT _ FROM _ ORDER BY INDEX _@_ ASC -- identifiers removed

parse
SELECT a FROM t ORDER BY INDEX t@foo DESC
----
SELECT a FROM t ORDER BY INDEX t@foo DESC
SELECT (a) FROM t ORDER BY INDEX t@foo DESC -- fully parenthesized
SELECT a FROM t ORDER BY INDEX t@foo DESC -- literals removed
SELECT _ FROM _ ORDER BY INDEX _@_ DESC -- identifiers removed

parse
SELECT a FROM t ORDER BY INDEX t@primary
----
SELECT a FROM t ORDER BY INDEX t@primary
SELECT (a) FROM t ORDER BY INDEX t@primary -- fully parenthesized
SELECT a FROM t ORDER BY INDEX t@primary -- literals removed
SELECT _ FROM _ ORDER BY INDEX _@_ -- identifiers removed

parse
SELECT a FROM t ORDER BY INDEX t@like
----
SELECT a FROM t ORDER BY INDEX t@like
SELECT (a) FROM t ORDER BY INDEX t@like -- fully parenthesized
SELECT a FROM t ORDER BY INDEX t@like -- literals removed
SELECT _ FROM _ ORDER BY INDEX _@_ -- identifiers removed

parse
SELECT a FROM t ORDER BY a NULLS FIRST
----
SELECT a FROM t ORDER BY a NULLS FIRST
SELECT (a) FROM t ORDER BY (a) NULLS FIRST -- fully parenthesized
SELECT a FROM t ORDER BY a NULLS FIRST -- literals removed
SELECT _ FROM _ ORDER BY _ NULLS FIRST -- identifiers removed

parse
SELECT a FROM t ORDER BY a ASC NULLS FIRST
----
SELECT a FROM t ORDER BY a ASC NULLS FIRST
SELECT (a) FROM t ORDER BY (a) ASC NULLS FIRST -- fully parenthesized
SELECT a FROM t ORDER BY a ASC NULLS FIRST -- literals removed
SELECT _ FROM _ ORDER BY _ ASC NULLS FIRST -- identifiers removed

parse
SELECT a FROM t ORDER BY a DESC NULLS LAST
----
SELECT a FROM t ORDER BY a DESC NULLS LAST
SELECT (a) FROM t ORDER BY (a) DESC NULLS LAST -- fully parenthesized
SELECT a FROM t ORDER BY a DESC NULLS LAST -- literals removed
SELECT _ FROM _ ORDER BY _ DESC NULLS LAST -- identifiers removed

parse
SELECT 1 FROM t GROUP BY a
----
SELECT 1 FROM t GROUP BY a
SELECT (1) FROM t GROUP BY (a) -- fully parenthesized
SELECT _ FROM t GROUP BY a -- literals removed
SELECT 1 FROM _ GROUP BY _ -- identifiers removed

parse
SELECT 1 FROM t GROUP BY a, b
----
SELECT 1 FROM t GROUP BY a, b
SELECT (1) FROM t GROUP BY (a), (b) -- fully parenthesized
SELECT _ FROM t GROUP BY a, b -- literals removed
SELECT 1 FROM _ GROUP BY _, _ -- identifiers removed

parse
SELECT 1 FROM t GROUP BY ()
----
SELECT 1 FROM t GROUP BY ()
SELECT (1) FROM t GROUP BY (()) -- fully parenthesized
SELECT _ FROM t GROUP BY () -- literals removed
SELECT 1 FROM _ GROUP BY () -- identifiers removed

parse
SELECT sum(x ORDER BY y) FROM t
----
SELECT sum(x ORDER BY y) FROM t
SELECT (sum((x) ORDER BY (y))) FROM t -- fully parenthesized
SELECT sum(x ORDER BY y) FROM t -- literals removed
SELECT _(_ ORDER BY _) FROM _ -- identifiers removed

parse
SELECT sum(x ORDER BY y, z) FROM t
----
SELECT sum(x ORDER BY y, z) FROM t
SELECT (sum((x) ORDER BY (y), (z))) FROM t -- fully parenthesized
SELECT sum(x ORDER BY y, z) FROM t -- literals removed
SELECT _(_ ORDER BY _, _) FROM _ -- identifiers removed

parse
SELECT a FROM t HAVING a = b
----
SELECT a FROM t HAVING a = b
SELECT (a) FROM t HAVING ((a) = (b)) -- fully parenthesized
SELECT a FROM t HAVING a = b -- literals removed
SELECT _ FROM _ HAVING _ = _ -- identifiers removed

parse
SELECT a FROM t WINDOW w AS ()
----
SELECT a FROM t WINDOW w AS ()
SELECT (a) FROM t WINDOW w AS () -- fully parenthesized
SELECT a FROM t WINDOW w AS () -- literals removed
SELECT _ FROM _ WINDOW _ AS () -- identifiers removed

parse
SELECT a FROM t WINDOW w AS (w2)
----
SELECT a FROM t WINDOW w AS (w2)
SELECT (a) FROM t WINDOW w AS (w2) -- fully parenthesized
SELECT a FROM t WINDOW w AS (w2) -- literals removed
SELECT _ FROM _ WINDOW _ AS (_) -- identifiers removed

parse
SELECT a FROM t WINDOW w AS (PARTITION BY b)
----
SELECT a FROM t WINDOW w AS (PARTITION BY b)
SELECT (a) FROM t WINDOW w AS (PARTITION BY (b)) -- fully parenthesized
SELECT a FROM t WINDOW w AS (PARTITION BY b) -- literals removed
SELECT _ FROM _ WINDOW _ AS (PARTITION BY _) -- identifiers removed

parse
SELECT a FROM t WINDOW w AS (PARTITION BY b, 1 + 2)
----
SELECT a FROM t WINDOW w AS (PARTITION BY b, 1 + 2)
SELECT (a) FROM t WINDOW w AS (PARTITION BY (b), ((1) + (2))) -- fully parenthesized
SELECT a FROM t WINDOW w AS (PARTITION BY b, _ + _) -- literals removed
SELECT _ FROM _ WINDOW _ AS (PARTITION BY _, 1 + 2) -- identifiers removed

parse
SELECT a FROM t WINDOW w AS (ORDER BY c)
----
SELECT a FROM t WINDOW w AS (ORDER BY c)
SELECT (a) FROM t WINDOW w AS (ORDER BY (c)) -- fully parenthesized
SELECT a FROM t WINDOW w AS (ORDER BY c) -- literals removed
SELECT _ FROM _ WINDOW _ AS (ORDER BY _) -- identifiers removed

parse
SELECT a FROM t WINDOW w AS (ORDER BY c, 1 + 2)
----
SELECT a FROM t WINDOW w AS (ORDER BY c, 1 + 2)
SELECT (a) FROM t WINDOW w AS (ORDER BY (c), ((1) + (2))) -- fully parenthesized
SELECT a FROM t WINDOW w AS (ORDER BY c, _ + _) -- literals removed
SELECT _ FROM _ WINDOW _ AS (ORDER BY _, 1 + 2) -- identifiers removed

parse
SELECT a FROM t WINDOW w AS (PARTITION BY b ORDER BY c)
----
SELECT a FROM t WINDOW w AS (PARTITION BY b ORDER BY c)
SELECT (a) FROM t WINDOW w AS (PARTITION BY (b) ORDER BY (c)) -- fully parenthesized
SELECT a FROM t WINDOW w AS (PARTITION BY b ORDER BY c) -- literals removed
SELECT _ FROM _ WINDOW _ AS (PARTITION BY _ ORDER BY _) -- identifiers removed

parse
SELECT avg(1) OVER w FROM t
----
SELECT avg(1) OVER w FROM t
SELECT (avg((1)) OVER w) FROM t -- fully parenthesized
SELECT avg(_) OVER w FROM t -- literals removed
SELECT _(1) OVER _ FROM _ -- identifiers removed

parse
SELECT avg(1) OVER () FROM t
----
SELECT avg(1) OVER () FROM t
SELECT (avg((1)) OVER ()) FROM t -- fully parenthesized
SELECT avg(_) OVER () FROM t -- literals removed
SELECT _(1) OVER () FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (w) FROM t
----
SELECT avg(1) OVER (w) FROM t
SELECT (avg((1)) OVER (w)) FROM t -- fully parenthesized
SELECT avg(_) OVER (w) FROM t -- literals removed
SELECT _(1) OVER (_) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (PARTITION BY b) FROM t
----
SELECT avg(1) OVER (PARTITION BY b) FROM t
SELECT (avg((1)) OVER (PARTITION BY (b))) FROM t -- fully parenthesized
SELECT avg(_) OVER (PARTITION BY b) FROM t -- literals removed
SELECT _(1) OVER (PARTITION BY _) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ORDER BY c) FROM t
----
SELECT avg(1) OVER (ORDER BY c) FROM t
SELECT (avg((1)) OVER (ORDER BY (c))) FROM t -- fully parenthesized
SELECT avg(_) OVER (ORDER BY c) FROM t -- literals removed
SELECT _(1) OVER (ORDER BY _) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (PARTITION BY b ORDER BY c) FROM t
----
SELECT avg(1) OVER (PARTITION BY b ORDER BY c) FROM t
SELECT (avg((1)) OVER (PARTITION BY (b) ORDER BY (c))) FROM t -- fully parenthesized
SELECT avg(_) OVER (PARTITION BY b ORDER BY c) FROM t -- literals removed
SELECT _(1) OVER (PARTITION BY _ ORDER BY _) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (w PARTITION BY b ORDER BY c) FROM t
----
SELECT avg(1) OVER (w PARTITION BY b ORDER BY c) FROM t
SELECT (avg((1)) OVER (w PARTITION BY (b) ORDER BY (c))) FROM t -- fully parenthesized
SELECT avg(_) OVER (w PARTITION BY b ORDER BY c) FROM t -- literals removed
SELECT _(1) OVER (_ PARTITION BY _ ORDER BY _) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (ROWS UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (ROWS UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (ROWS UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS 1 PRECEDING) FROM t
----
SELECT avg(1) OVER (ROWS 1 PRECEDING) FROM t
SELECT (avg((1)) OVER (ROWS (1) PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS _ PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (ROWS 1 PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS CURRENT ROW) FROM t
----
SELECT avg(1) OVER (ROWS CURRENT ROW) FROM t
SELECT (avg((1)) OVER (ROWS CURRENT ROW)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS CURRENT ROW) FROM t -- literals removed
SELECT _(1) OVER (ROWS CURRENT ROW) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) FROM t
----
SELECT avg(1) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) FROM t
SELECT (avg((1)) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND (1) PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND _ PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM t
----
SELECT avg(1) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM t
SELECT (avg((1)) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM t -- literals removed
SELECT _(1) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING) FROM t
----
SELECT avg(1) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING) FROM t
SELECT (avg((1)) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND (1) FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND _ FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM t
----
SELECT avg(1) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM t
SELECT (avg((1)) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING) FROM t
----
SELECT avg(1) OVER (ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING) FROM t
SELECT (avg((1)) OVER (ROWS BETWEEN (1) PRECEDING AND (1) PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS BETWEEN _ PRECEDING AND _ PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) FROM t
----
SELECT avg(1) OVER (ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) FROM t
SELECT (avg((1)) OVER (ROWS BETWEEN (1) PRECEDING AND CURRENT ROW)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS BETWEEN _ PRECEDING AND CURRENT ROW) FROM t -- literals removed
SELECT _(1) OVER (ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM t
----
SELECT avg(1) OVER (ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM t
SELECT (avg((1)) OVER (ROWS BETWEEN (1) PRECEDING AND (1) FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS BETWEEN _ PRECEDING AND _ FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS BETWEEN 1 PRECEDING AND UNBOUNDED FOLLOWING) FROM t
----
SELECT avg(1) OVER (ROWS BETWEEN 1 PRECEDING AND UNBOUNDED FOLLOWING) FROM t
SELECT (avg((1)) OVER (ROWS BETWEEN (1) PRECEDING AND UNBOUNDED FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS BETWEEN _ PRECEDING AND UNBOUNDED FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (ROWS BETWEEN 1 PRECEDING AND UNBOUNDED FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS BETWEEN CURRENT ROW AND CURRENT ROW) FROM t
----
SELECT avg(1) OVER (ROWS BETWEEN CURRENT ROW AND CURRENT ROW) FROM t
SELECT (avg((1)) OVER (ROWS BETWEEN CURRENT ROW AND CURRENT ROW)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS BETWEEN CURRENT ROW AND CURRENT ROW) FROM t -- literals removed
SELECT _(1) OVER (ROWS BETWEEN CURRENT ROW AND CURRENT ROW) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING) FROM t
----
SELECT avg(1) OVER (ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING) FROM t
SELECT (avg((1)) OVER (ROWS BETWEEN CURRENT ROW AND (1) FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS BETWEEN CURRENT ROW AND _ FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) FROM t
----
SELECT avg(1) OVER (ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) FROM t
SELECT (avg((1)) OVER (ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS BETWEEN 1 FOLLOWING AND 1 FOLLOWING) FROM t
----
SELECT avg(1) OVER (ROWS BETWEEN 1 FOLLOWING AND 1 FOLLOWING) FROM t
SELECT (avg((1)) OVER (ROWS BETWEEN (1) FOLLOWING AND (1) FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS BETWEEN _ FOLLOWING AND _ FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (ROWS BETWEEN 1 FOLLOWING AND 1 FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING) FROM t
----
SELECT avg(1) OVER (ROWS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING) FROM t
SELECT (avg((1)) OVER (ROWS BETWEEN (1) FOLLOWING AND UNBOUNDED FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS BETWEEN _ FOLLOWING AND UNBOUNDED FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (ROWS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (w ROWS UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (w ROWS UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (w ROWS UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (w ROWS UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (_ ROWS UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (PARTITION BY b ROWS UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (PARTITION BY b ROWS UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (PARTITION BY (b) ROWS UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (PARTITION BY b ROWS UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (PARTITION BY _ ROWS UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ORDER BY c ROWS UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (ORDER BY c ROWS UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (ORDER BY (c) ROWS UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ORDER BY c ROWS UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (ORDER BY _ ROWS UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (PARTITION BY b ORDER BY c ROWS UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (PARTITION BY b ORDER BY c ROWS UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (PARTITION BY (b) ORDER BY (c) ROWS UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (PARTITION BY b ORDER BY c ROWS UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (PARTITION BY _ ORDER BY _ ROWS UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (w PARTITION BY b ORDER BY c ROWS UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (w PARTITION BY b ORDER BY c ROWS UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (w PARTITION BY (b) ORDER BY (c) ROWS UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (w PARTITION BY b ORDER BY c ROWS UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (_ PARTITION BY _ ORDER BY _ ROWS UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (RANGE UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (RANGE UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (RANGE UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (RANGE UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (RANGE UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (RANGE 1 PRECEDING) FROM t
----
SELECT avg(1) OVER (RANGE 1 PRECEDING) FROM t
SELECT (avg((1)) OVER (RANGE (1) PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (RANGE _ PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (RANGE 1 PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (RANGE CURRENT ROW) FROM t
----
SELECT avg(1) OVER (RANGE CURRENT ROW) FROM t
SELECT (avg((1)) OVER (RANGE CURRENT ROW)) FROM t -- fully parenthesized
SELECT avg(_) OVER (RANGE CURRENT ROW) FROM t -- literals removed
SELECT _(1) OVER (RANGE CURRENT ROW) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) FROM t
----
SELECT avg(1) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) FROM t
SELECT (avg((1)) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND (1) PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND _ PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM t
----
SELECT avg(1) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM t
SELECT (avg((1)) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)) FROM t -- fully parenthesized
SELECT avg(_) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM t -- literals removed
SELECT _(1) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING) FROM t
----
SELECT avg(1) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING) FROM t
SELECT (avg((1)) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND (1) FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND _ FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM t
----
SELECT avg(1) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM t
SELECT (avg((1)) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (RANGE BETWEEN 1 PRECEDING AND 1 PRECEDING) FROM t
----
SELECT avg(1) OVER (RANGE BETWEEN 1 PRECEDING AND 1 PRECEDING) FROM t
SELECT (avg((1)) OVER (RANGE BETWEEN (1) PRECEDING AND (1) PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (RANGE BETWEEN _ PRECEDING AND _ PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (RANGE BETWEEN 1 PRECEDING AND 1 PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (RANGE BETWEEN 1 PRECEDING AND CURRENT ROW) FROM t
----
SELECT avg(1) OVER (RANGE BETWEEN 1 PRECEDING AND CURRENT ROW) FROM t
SELECT (avg((1)) OVER (RANGE BETWEEN (1) PRECEDING AND CURRENT ROW)) FROM t -- fully parenthesized
SELECT avg(_) OVER (RANGE BETWEEN _ PRECEDING AND CURRENT ROW) FROM t -- literals removed
SELECT _(1) OVER (RANGE BETWEEN 1 PRECEDING AND CURRENT ROW) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM t
----
SELECT avg(1) OVER (RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM t
SELECT (avg((1)) OVER (RANGE BETWEEN (1) PRECEDING AND (1) FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (RANGE BETWEEN _ PRECEDING AND _ FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (RANGE BETWEEN 1 PRECEDING AND UNBOUNDED FOLLOWING) FROM t
----
SELECT avg(1) OVER (RANGE BETWEEN 1 PRECEDING AND UNBOUNDED FOLLOWING) FROM t
SELECT (avg((1)) OVER (RANGE BETWEEN (1) PRECEDING AND UNBOUNDED FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (RANGE BETWEEN _ PRECEDING AND UNBOUNDED FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (RANGE BETWEEN 1 PRECEDING AND UNBOUNDED FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (RANGE BETWEEN CURRENT ROW AND CURRENT ROW) FROM t
----
SELECT avg(1) OVER (RANGE BETWEEN CURRENT ROW AND CURRENT ROW) FROM t
SELECT (avg((1)) OVER (RANGE BETWEEN CURRENT ROW AND CURRENT ROW)) FROM t -- fully parenthesized
SELECT avg(_) OVER (RANGE BETWEEN CURRENT ROW AND CURRENT ROW) FROM t -- literals removed
SELECT _(1) OVER (RANGE BETWEEN CURRENT ROW AND CURRENT ROW) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (RANGE BETWEEN CURRENT ROW AND 1 FOLLOWING) FROM t
----
SELECT avg(1) OVER (RANGE BETWEEN CURRENT ROW AND 1 FOLLOWING) FROM t
SELECT (avg((1)) OVER (RANGE BETWEEN CURRENT ROW AND (1) FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (RANGE BETWEEN CURRENT ROW AND _ FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (RANGE BETWEEN CURRENT ROW AND 1 FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) FROM t
----
SELECT avg(1) OVER (RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) FROM t
SELECT (avg((1)) OVER (RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (RANGE BETWEEN 1 FOLLOWING AND 1 FOLLOWING) FROM t
----
SELECT avg(1) OVER (RANGE BETWEEN 1 FOLLOWING AND 1 FOLLOWING) FROM t
SELECT (avg((1)) OVER (RANGE BETWEEN (1) FOLLOWING AND (1) FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (RANGE BETWEEN _ FOLLOWING AND _ FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (RANGE BETWEEN 1 FOLLOWING AND 1 FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (RANGE BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING) FROM t
----
SELECT avg(1) OVER (RANGE BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING) FROM t
SELECT (avg((1)) OVER (RANGE BETWEEN (1) FOLLOWING AND UNBOUNDED FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (RANGE BETWEEN _ FOLLOWING AND UNBOUNDED FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (RANGE BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (w RANGE UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (w RANGE UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (w RANGE UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (w RANGE UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (_ RANGE UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (PARTITION BY b RANGE UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (PARTITION BY b RANGE UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (PARTITION BY (b) RANGE UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (PARTITION BY b RANGE UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (PARTITION BY _ RANGE UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ORDER BY c RANGE UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (ORDER BY c RANGE UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (ORDER BY (c) RANGE UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ORDER BY c RANGE UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (ORDER BY _ RANGE UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (PARTITION BY b ORDER BY c RANGE UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (PARTITION BY b ORDER BY c RANGE UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (PARTITION BY (b) ORDER BY (c) RANGE UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (PARTITION BY b ORDER BY c RANGE UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (PARTITION BY _ ORDER BY _ RANGE UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (w PARTITION BY b ORDER BY c RANGE UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (w PARTITION BY b ORDER BY c RANGE UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (w PARTITION BY (b) ORDER BY (c) RANGE UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (w PARTITION BY b ORDER BY c RANGE UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (_ PARTITION BY _ ORDER BY _ RANGE UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (GROUPS UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (GROUPS UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (GROUPS UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (GROUPS UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (GROUPS UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (GROUPS 1 PRECEDING) FROM t
----
SELECT avg(1) OVER (GROUPS 1 PRECEDING) FROM t
SELECT (avg((1)) OVER (GROUPS (1) PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (GROUPS _ PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (GROUPS 1 PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (GROUPS CURRENT ROW) FROM t
----
SELECT avg(1) OVER (GROUPS CURRENT ROW) FROM t
SELECT (avg((1)) OVER (GROUPS CURRENT ROW)) FROM t -- fully parenthesized
SELECT avg(_) OVER (GROUPS CURRENT ROW) FROM t -- literals removed
SELECT _(1) OVER (GROUPS CURRENT ROW) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) FROM t
----
SELECT avg(1) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) FROM t
SELECT (avg((1)) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND (1) PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND _ PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM t
----
SELECT avg(1) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM t
SELECT (avg((1)) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)) FROM t -- fully parenthesized
SELECT avg(_) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM t -- literals removed
SELECT _(1) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING) FROM t
----
SELECT avg(1) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING) FROM t
SELECT (avg((1)) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND (1) FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND _ FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM t
----
SELECT avg(1) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM t
SELECT (avg((1)) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (GROUPS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (GROUPS BETWEEN 1 PRECEDING AND 1 PRECEDING) FROM t
----
SELECT avg(1) OVER (GROUPS BETWEEN 1 PRECEDING AND 1 PRECEDING) FROM t
SELECT (avg((1)) OVER (GROUPS BETWEEN (1) PRECEDING AND (1) PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (GROUPS BETWEEN _ PRECEDING AND _ PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (GROUPS BETWEEN 1 PRECEDING AND 1 PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (GROUPS BETWEEN 1 PRECEDING AND CURRENT ROW) FROM t
----
SELECT avg(1) OVER (GROUPS BETWEEN 1 PRECEDING AND CURRENT ROW) FROM t
SELECT (avg((1)) OVER (GROUPS BETWEEN (1) PRECEDING AND CURRENT ROW)) FROM t -- fully parenthesized
SELECT avg(_) OVER (GROUPS BETWEEN _ PRECEDING AND CURRENT ROW) FROM t -- literals removed
SELECT _(1) OVER (GROUPS BETWEEN 1 PRECEDING AND CURRENT ROW) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (GROUPS BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM t
----
SELECT avg(1) OVER (GROUPS BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM t
SELECT (avg((1)) OVER (GROUPS BETWEEN (1) PRECEDING AND (1) FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (GROUPS BETWEEN _ PRECEDING AND _ FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (GROUPS BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (GROUPS BETWEEN 1 PRECEDING AND UNBOUNDED FOLLOWING) FROM t
----
SELECT avg(1) OVER (GROUPS BETWEEN 1 PRECEDING AND UNBOUNDED FOLLOWING) FROM t
SELECT (avg((1)) OVER (GROUPS BETWEEN (1) PRECEDING AND UNBOUNDED FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (GROUPS BETWEEN _ PRECEDING AND UNBOUNDED FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (GROUPS BETWEEN 1 PRECEDING AND UNBOUNDED FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (GROUPS BETWEEN CURRENT ROW AND CURRENT ROW) FROM t
----
SELECT avg(1) OVER (GROUPS BETWEEN CURRENT ROW AND CURRENT ROW) FROM t
SELECT (avg((1)) OVER (GROUPS BETWEEN CURRENT ROW AND CURRENT ROW)) FROM t -- fully parenthesized
SELECT avg(_) OVER (GROUPS BETWEEN CURRENT ROW AND CURRENT ROW) FROM t -- literals removed
SELECT _(1) OVER (GROUPS BETWEEN CURRENT ROW AND CURRENT ROW) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (GROUPS BETWEEN CURRENT ROW AND 1 FOLLOWING) FROM t
----
SELECT avg(1) OVER (GROUPS BETWEEN CURRENT ROW AND 1 FOLLOWING) FROM t
SELECT (avg((1)) OVER (GROUPS BETWEEN CURRENT ROW AND (1) FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (GROUPS BETWEEN CURRENT ROW AND _ FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (GROUPS BETWEEN CURRENT ROW AND 1 FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (GROUPS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) FROM t
----
SELECT avg(1) OVER (GROUPS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) FROM t
SELECT (avg((1)) OVER (GROUPS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (GROUPS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (GROUPS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (GROUPS BETWEEN 1 FOLLOWING AND 1 FOLLOWING) FROM t
----
SELECT avg(1) OVER (GROUPS BETWEEN 1 FOLLOWING AND 1 FOLLOWING) FROM t
SELECT (avg((1)) OVER (GROUPS BETWEEN (1) FOLLOWING AND (1) FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (GROUPS BETWEEN _ FOLLOWING AND _ FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (GROUPS BETWEEN 1 FOLLOWING AND 1 FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (GROUPS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING) FROM t
----
SELECT avg(1) OVER (GROUPS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING) FROM t
SELECT (avg((1)) OVER (GROUPS BETWEEN (1) FOLLOWING AND UNBOUNDED FOLLOWING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (GROUPS BETWEEN _ FOLLOWING AND UNBOUNDED FOLLOWING) FROM t -- literals removed
SELECT _(1) OVER (GROUPS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (w GROUPS UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (w GROUPS UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (w GROUPS UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (w GROUPS UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (_ GROUPS UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (PARTITION BY b GROUPS UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (PARTITION BY b GROUPS UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (PARTITION BY (b) GROUPS UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (PARTITION BY b GROUPS UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (PARTITION BY _ GROUPS UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ORDER BY c GROUPS UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (ORDER BY c GROUPS UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (ORDER BY (c) GROUPS UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ORDER BY c GROUPS UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (ORDER BY _ GROUPS UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (PARTITION BY b ORDER BY c GROUPS UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (PARTITION BY b ORDER BY c GROUPS UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (PARTITION BY (b) ORDER BY (c) GROUPS UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (PARTITION BY b ORDER BY c GROUPS UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (PARTITION BY _ ORDER BY _ GROUPS UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (w PARTITION BY b ORDER BY c GROUPS UNBOUNDED PRECEDING) FROM t
----
SELECT avg(1) OVER (w PARTITION BY b ORDER BY c GROUPS UNBOUNDED PRECEDING) FROM t
SELECT (avg((1)) OVER (w PARTITION BY (b) ORDER BY (c) GROUPS UNBOUNDED PRECEDING)) FROM t -- fully parenthesized
SELECT avg(_) OVER (w PARTITION BY b ORDER BY c GROUPS UNBOUNDED PRECEDING) FROM t -- literals removed
SELECT _(1) OVER (_ PARTITION BY _ ORDER BY _ GROUPS UNBOUNDED PRECEDING) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS UNBOUNDED PRECEDING EXCLUDE CURRENT ROW) FROM t
----
SELECT avg(1) OVER (ROWS UNBOUNDED PRECEDING EXCLUDE CURRENT ROW) FROM t
SELECT (avg((1)) OVER (ROWS UNBOUNDED PRECEDING EXCLUDE CURRENT ROW)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS UNBOUNDED PRECEDING EXCLUDE CURRENT ROW) FROM t -- literals removed
SELECT _(1) OVER (ROWS UNBOUNDED PRECEDING EXCLUDE CURRENT ROW) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS UNBOUNDED PRECEDING EXCLUDE GROUP) FROM t
----
SELECT avg(1) OVER (ROWS UNBOUNDED PRECEDING EXCLUDE GROUP) FROM t
SELECT (avg((1)) OVER (ROWS UNBOUNDED PRECEDING EXCLUDE GROUP)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS UNBOUNDED PRECEDING EXCLUDE GROUP) FROM t -- literals removed
SELECT _(1) OVER (ROWS UNBOUNDED PRECEDING EXCLUDE GROUP) FROM _ -- identifiers removed

parse
SELECT avg(1) OVER (ROWS UNBOUNDED PRECEDING EXCLUDE TIES) FROM t
----
SELECT avg(1) OVER (ROWS UNBOUNDED PRECEDING EXCLUDE TIES) FROM t
SELECT (avg((1)) OVER (ROWS UNBOUNDED PRECEDING EXCLUDE TIES)) FROM t -- fully parenthesized
SELECT avg(_) OVER (ROWS UNBOUNDED PRECEDING EXCLUDE TIES) FROM t -- literals removed
SELECT _(1) OVER (ROWS UNBOUNDED PRECEDING EXCLUDE TIES) FROM _ -- identifiers removed

error
SELECT avg(1) OVER (ROWS UNBOUNDED FOLLOWING) FROM t
----
at or near "following": syntax error: frame start cannot be UNBOUNDED FOLLOWING
DETAIL: source SQL:
SELECT avg(1) OVER (ROWS UNBOUNDED FOLLOWING) FROM t
                                   ^

error
SELECT avg(1) OVER (ROWS 1 FOLLOWING) FROM t
----
at or near "following": syntax error: frame starting from following row cannot end with current row
DETAIL: source SQL:
SELECT avg(1) OVER (ROWS 1 FOLLOWING) FROM t
                           ^

error
SELECT avg(1) OVER (ROWS BETWEEN UNBOUNDED FOLLOWING AND UNBOUNDED FOLLOWING) FROM t
----
at or near "following": syntax error: frame start cannot be UNBOUNDED FOLLOWING
DETAIL: source SQL:
SELECT avg(1) OVER (ROWS BETWEEN UNBOUNDED FOLLOWING AND UNBOUNDED FOLLOWING) FROM t
                                                                   ^

error
SELECT avg(1) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED PRECEDING) FROM t
----
at or near "preceding": syntax error: frame end cannot be UNBOUNDED PRECEDING
DETAIL: source SQL:
SELECT avg(1) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED PRECEDING) FROM t
                                                                   ^

error
SELECT avg(1) OVER (ROWS BETWEEN CURRENT ROW AND 1 PRECEDING) FROM t
----
at or near "preceding": syntax error: frame starting from current row cannot have preceding rows
DETAIL: source SQL:
SELECT avg(1) OVER (ROWS BETWEEN CURRENT ROW AND 1 PRECEDING) FROM t
                                                   ^

error
SELECT avg(1) OVER (ROWS BETWEEN 1 FOLLOWING AND 1 PRECEDING) FROM t
----
at or near "preceding": syntax error: frame starting from following row cannot have preceding rows
DETAIL: source SQL:
SELECT avg(1) OVER (ROWS BETWEEN 1 FOLLOWING AND 1 PRECEDING) FROM t
                                                   ^

error
SELECT avg(1) OVER (ROWS BETWEEN 1 FOLLOWING AND CURRENT ROW) FROM t
----
at or near "row": syntax error: frame starting from following row cannot have preceding rows
DETAIL: source SQL:
SELECT avg(1) OVER (ROWS BETWEEN 1 FOLLOWING AND CURRENT ROW) FROM t
                                                         ^

parse
SELECT percentile_disc(0.50) WITHIN GROUP (ORDER BY c) FROM t
----
SELECT percentile_disc(0.50) WITHIN GROUP (ORDER BY c) FROM t
SELECT (percentile_disc((0.50)) WITHIN GROUP (ORDER BY (c))) FROM t -- fully parenthesized
SELECT percentile_disc(_) WITHIN GROUP (ORDER BY c) FROM t -- literals removed
SELECT _(0.50) WITHIN GROUP (ORDER BY _) FROM _ -- identifiers removed

parse
SELECT percentile_disc(0.50) WITHIN GROUP (ORDER BY c DESC) FROM t
----
SELECT percentile_disc(0.50) WITHIN GROUP (ORDER BY c DESC) FROM t
SELECT (percentile_disc((0.50)) WITHIN GROUP (ORDER BY (c) DESC)) FROM t -- fully parenthesized
SELECT percentile_disc(_) WITHIN GROUP (ORDER BY c DESC) FROM t -- literals removed
SELECT _(0.50) WITHIN GROUP (ORDER BY _ DESC) FROM _ -- identifiers removed

parse
SELECT percentile_cont(0.50) WITHIN GROUP (ORDER BY c) FROM t
----
SELECT percentile_cont(0.50) WITHIN GROUP (ORDER BY c) FROM t
SELECT (percentile_cont((0.50)) WITHIN GROUP (ORDER BY (c))) FROM t -- fully parenthesized
SELECT percentile_cont(_) WITHIN GROUP (ORDER BY c) FROM t -- literals removed
SELECT _(0.50) WITHIN GROUP (ORDER BY _) FROM _ -- identifiers removed

parse
SELECT percentile_disc(ARRAY[0.95, 0.90]) WITHIN GROUP (ORDER BY c) FROM t
----
SELECT percentile_disc(ARRAY[0.95, 0.90]) WITHIN GROUP (ORDER BY c) FROM t
SELECT (percentile_disc((ARRAY[(0.95), (0.90)])) WITHIN GROUP (ORDER BY (c))) FROM t -- fully parenthesized
SELECT percentile_disc(ARRAY[_, _]) WITHIN GROUP (ORDER BY c) FROM t -- literals removed
SELECT _(ARRAY[0.95, 0.90]) WITHIN GROUP (ORDER BY _) FROM _ -- identifiers removed

parse
SELECT percentile_cont(ARRAY[0.95, 0.90]) WITHIN GROUP (ORDER BY c) FROM t
----
SELECT percentile_cont(ARRAY[0.95, 0.90]) WITHIN GROUP (ORDER BY c) FROM t
SELECT (percentile_cont((ARRAY[(0.95), (0.90)])) WITHIN GROUP (ORDER BY (c))) FROM t -- fully parenthesized
SELECT percentile_cont(ARRAY[_, _]) WITHIN GROUP (ORDER BY c) FROM t -- literals removed
SELECT _(ARRAY[0.95, 0.90]) WITHIN GROUP (ORDER BY _) FROM _ -- identifiers removed

error
SELECT percentile_disc(0.50) WITHIN GROUP (ORDER BY f, s) FROM x;
----
at or near ")": syntax error: multiple ORDER BY clauses are not supported in this function
DETAIL: source SQL:
SELECT percentile_disc(0.50) WITHIN GROUP (ORDER BY f, s) FROM x
                                                        ^

parse
SELECT avg(1) FILTER (WHERE a > b)
----
SELECT avg(1) FILTER (WHERE a > b)
SELECT (avg((1)) FILTER (WHERE ((a) > (b)))) -- fully parenthesized
SELECT avg(_) FILTER (WHERE a > b) -- literals removed
SELECT _(1) FILTER (WHERE _ > _) -- identifiers removed

parse
SELECT avg(1) FILTER (WHERE a > b) OVER (ORDER BY c)
----
SELECT avg(1) FILTER (WHERE a > b) OVER (ORDER BY c)
SELECT (avg((1)) FILTER (WHERE ((a) > (b))) OVER (ORDER BY (c))) -- fully parenthesized
SELECT avg(_) FILTER (WHERE a > b) OVER (ORDER BY c) -- literals removed
SELECT _(1) FILTER (WHERE _ > _) OVER (ORDER BY _) -- identifiers removed

parse
SELECT a FROM t UNION SELECT 1 FROM t
----
SELECT a FROM t UNION SELECT 1 FROM t
SELECT (a) FROM t UNION SELECT (1) FROM t -- fully parenthesized
SELECT a FROM t UNION SELECT _ FROM t -- literals removed
SELECT _ FROM _ UNION SELECT 1 FROM _ -- identifiers removed

parse
SELECT a FROM t UNION SELECT 1 FROM t UNION SELECT 1 FROM t
----
SELECT a FROM t UNION SELECT 1 FROM t UNION SELECT 1 FROM t
SELECT (a) FROM t UNION SELECT (1) FROM t UNION SELECT (1) FROM t -- fully parenthesized
SELECT a FROM t UNION SELECT _ FROM t UNION SELECT _ FROM t -- literals removed
SELECT _ FROM _ UNION SELECT 1 FROM _ UNION SELECT 1 FROM _ -- identifiers removed

parse
SELECT a FROM t UNION ALL SELECT 1 FROM t
----
SELECT a FROM t UNION ALL SELECT 1 FROM t
SELECT (a) FROM t UNION ALL SELECT (1) FROM t -- fully parenthesized
SELECT a FROM t UNION ALL SELECT _ FROM t -- literals removed
SELECT _ FROM _ UNION ALL SELECT 1 FROM _ -- identifiers removed

parse
SELECT a FROM t UNION DISTINCT SELECT 1 FROM t
----
SELECT a FROM t UNION SELECT 1 FROM t -- normalized!
SELECT (a) FROM t UNION SELECT (1) FROM t -- fully parenthesized
SELECT a FROM t UNION SELECT _ FROM t -- literals removed
SELECT _ FROM _ UNION SELECT 1 FROM _ -- identifiers removed


parse
SELECT a FROM t EXCEPT SELECT 1 FROM t
----
SELECT a FROM t EXCEPT SELECT 1 FROM t
SELECT (a) FROM t EXCEPT SELECT (1) FROM t -- fully parenthesized
SELECT a FROM t EXCEPT SELECT _ FROM t -- literals removed
SELECT _ FROM _ EXCEPT SELECT 1 FROM _ -- identifiers removed

parse
SELECT a FROM t EXCEPT ALL SELECT 1 FROM t
----
SELECT a FROM t EXCEPT ALL SELECT 1 FROM t
SELECT (a) FROM t EXCEPT ALL SELECT (1) FROM t -- fully parenthesized
SELECT a FROM t EXCEPT ALL SELECT _ FROM t -- literals removed
SELECT _ FROM _ EXCEPT ALL SELECT 1 FROM _ -- identifiers removed

parse
SELECT a FROM t EXCEPT DISTINCT SELECT 1 FROM t
----
SELECT a FROM t EXCEPT SELECT 1 FROM t -- normalized!
SELECT (a) FROM t EXCEPT SELECT (1) FROM t -- fully parenthesized
SELECT a FROM t EXCEPT SELECT _ FROM t -- literals removed
SELECT _ FROM _ EXCEPT SELECT 1 FROM _ -- identifiers removed

parse
SELECT a FROM t INTERSECT SELECT 1 FROM t
----
SELECT a FROM t INTERSECT SELECT 1 FROM t
SELECT (a) FROM t INTERSECT SELECT (1) FROM t -- fully parenthesized
SELECT a FROM t INTERSECT SELECT _ FROM t -- literals removed
SELECT _ FROM _ INTERSECT SELECT 1 FROM _ -- identifiers removed

parse
SELECT a FROM t INTERSECT ALL SELECT 1 FROM t
----
SELECT a FROM t INTERSECT ALL SELECT 1 FROM t
SELECT (a) FROM t INTERSECT ALL SELECT (1) FROM t -- fully parenthesized
SELECT a FROM t INTERSECT ALL SELECT _ FROM t -- literals removed
SELECT _ FROM _ INTERSECT ALL SELECT 1 FROM _ -- identifiers removed

parse
SELECT a FROM t INTERSECT DISTINCT SELECT 1 FROM t
----
SELECT a FROM t INTERSECT SELECT 1 FROM t -- normalized!
SELECT (a) FROM t INTERSECT SELECT (1) FROM t -- fully parenthesized
SELECT a FROM t INTERSECT SELECT _ FROM t -- literals removed
SELECT _ FROM _ INTERSECT SELECT 1 FROM _ -- identifiers removed

parse
SELECT a FROM t1 JOIN t2 ON a = b
----
SELECT a FROM t1 JOIN t2 ON a = b
SELECT (a) FROM t1 JOIN t2 ON ((a) = (b)) -- fully parenthesized
SELECT a FROM t1 JOIN t2 ON a = b -- literals removed
SELECT _ FROM _ JOIN _ ON _ = _ -- identifiers removed

parse
SELECT a FROM t1 JOIN t2 USING (a)
----
SELECT a FROM t1 JOIN t2 USING (a)
SELECT (a) FROM t1 JOIN t2 USING (a) -- fully parenthesized
SELECT a FROM t1 JOIN t2 USING (a) -- literals removed
SELECT _ FROM _ JOIN _ USING (_) -- identifiers removed

parse
SELECT a FROM t1 INNER MERGE JOIN t2 USING (a)
----
SELECT a FROM t1 INNER MERGE JOIN t2 USING (a)
SELECT (a) FROM t1 INNER MERGE JOIN t2 USING (a) -- fully parenthesized
SELECT a FROM t1 INNER MERGE JOIN t2 USING (a) -- literals removed
SELECT _ FROM _ INNER MERGE JOIN _ USING (_) -- identifiers removed

parse
SELECT a FROM t1 LEFT JOIN t2 ON a = b
----
SELECT a FROM t1 LEFT JOIN t2 ON a = b
SELECT (a) FROM t1 LEFT JOIN t2 ON ((a) = (b)) -- fully parenthesized
SELECT a FROM t1 LEFT JOIN t2 ON a = b -- literals removed
SELECT _ FROM _ LEFT JOIN _ ON _ = _ -- identifiers removed

parse
SELECT a FROM t1 LEFT OUTER JOIN t2 ON a = b
----
SELECT a FROM t1 LEFT JOIN t2 ON a = b -- normalized!
SELECT (a) FROM t1 LEFT JOIN t2 ON ((a) = (b)) -- fully parenthesized
SELECT a FROM t1 LEFT JOIN t2 ON a = b -- literals removed
SELECT _ FROM _ LEFT JOIN _ ON _ = _ -- identifiers removed

parse
SELECT a FROM t1 LEFT LOOKUP JOIN t2 ON a = b
----
SELECT a FROM t1 LEFT LOOKUP JOIN t2 ON a = b
SELECT (a) FROM t1 LEFT LOOKUP JOIN t2 ON ((a) = (b)) -- fully parenthesized
SELECT a FROM t1 LEFT LOOKUP JOIN t2 ON a = b -- literals removed
SELECT _ FROM _ LEFT LOOKUP JOIN _ ON _ = _ -- identifiers removed

parse
SELECT a FROM t1 LEFT INVERTED JOIN t2 ON a @> b
----
SELECT a FROM t1 LEFT INVERTED JOIN t2 ON a @> b
SELECT (a) FROM t1 LEFT INVERTED JOIN t2 ON ((a) @> (b)) -- fully parenthesized
SELECT a FROM t1 LEFT INVERTED JOIN t2 ON a @> b -- literals removed
SELECT _ FROM _ LEFT INVERTED JOIN _ ON _ @> _ -- identifiers removed

parse
SELECT a FROM t1 RIGHT JOIN t2 ON a = b
----
SELECT a FROM t1 RIGHT JOIN t2 ON a = b
SELECT (a) FROM t1 RIGHT JOIN t2 ON ((a) = (b)) -- fully parenthesized
SELECT a FROM t1 RIGHT JOIN t2 ON a = b -- literals removed
SELECT _ FROM _ RIGHT JOIN _ ON _ = _ -- identifiers removed

parse
SELECT a FROM t1 RIGHT OUTER JOIN t2 ON a = b
----
SELECT a FROM t1 RIGHT JOIN t2 ON a = b -- normalized!
SELECT (a) FROM t1 RIGHT JOIN t2 ON ((a) = (b)) -- fully parenthesized
SELECT a FROM t1 RIGHT JOIN t2 ON a = b -- literals removed
SELECT _ FROM _ RIGHT JOIN _ ON _ = _ -- identifiers removed

parse
SELECT a FROM t1 RIGHT OUTER MERGE JOIN t2 ON a = b
----
SELECT a FROM t1 RIGHT MERGE JOIN t2 ON a = b -- normalized!
SELECT (a) FROM t1 RIGHT MERGE JOIN t2 ON ((a) = (b)) -- fully parenthesized
SELECT a FROM t1 RIGHT MERGE JOIN t2 ON a = b -- literals removed
SELECT _ FROM _ RIGHT MERGE JOIN _ ON _ = _ -- identifiers removed


parse
SELECT a FROM t1 INNER JOIN t2 ON a = b
----
SELECT a FROM t1 INNER JOIN t2 ON a = b
SELECT (a) FROM t1 INNER JOIN t2 ON ((a) = (b)) -- fully parenthesized
SELECT a FROM t1 INNER JOIN t2 ON a = b -- literals removed
SELECT _ FROM _ INNER JOIN _ ON _ = _ -- identifiers removed

parse
SELECT a FROM t1 INNER STRAIGHT JOIN t2 ON a = b
----
SELECT a FROM t1 INNER STRAIGHT JOIN t2 ON a = b
SELECT (a) FROM t1 INNER STRAIGHT JOIN t2 ON ((a) = (b)) -- fully parenthesized
SELECT a FROM t1 INNER STRAIGHT JOIN t2 ON a = b -- literals removed
SELECT _ FROM _ INNER STRAIGHT JOIN _ ON _ = _ -- identifiers removed

parse
SELECT a FROM t1 INNER HASH JOIN t2 ON a = b
----
SELECT a FROM t1 INNER HASH JOIN t2 ON a = b
SELECT (a) FROM t1 INNER HASH JOIN t2 ON ((a) = (b)) -- fully parenthesized
SELECT a FROM t1 INNER HASH JOIN t2 ON a = b -- literals removed
SELECT _ FROM _ INNER HASH JOIN _ ON _ = _ -- identifiers removed

parse
SELECT a FROM t1 CROSS JOIN t2
----
SELECT a FROM t1 CROSS JOIN t2
SELECT (a) FROM t1 CROSS JOIN t2 -- fully parenthesized
SELECT a FROM t1 CROSS JOIN t2 -- literals removed
SELECT _ FROM _ CROSS JOIN _ -- identifiers removed

parse
SELECT a FROM t1 CROSS LOOKUP JOIN t2
----
SELECT a FROM t1 CROSS LOOKUP JOIN t2
SELECT (a) FROM t1 CROSS LOOKUP JOIN t2 -- fully parenthesized
SELECT a FROM t1 CROSS LOOKUP JOIN t2 -- literals removed
SELECT _ FROM _ CROSS LOOKUP JOIN _ -- identifiers removed

parse
SELECT a FROM t1 CROSS INVERTED JOIN t2
----
SELECT a FROM t1 CROSS INVERTED JOIN t2
SELECT (a) FROM t1 CROSS INVERTED JOIN t2 -- fully parenthesized
SELECT a FROM t1 CROSS INVERTED JOIN t2 -- literals removed
SELECT _ FROM _ CROSS INVERTED JOIN _ -- identifiers removed

parse
SELECT a FROM t1 NATURAL JOIN t2
----
SELECT a FROM t1 NATURAL JOIN t2
SELECT (a) FROM t1 NATURAL JOIN t2 -- fully parenthesized
SELECT a FROM t1 NATURAL JOIN t2 -- literals removed
SELECT _ FROM _ NATURAL JOIN _ -- identifiers removed

parse
SELECT a FROM t1 NATURAL INNER MERGE JOIN t2
----
SELECT a FROM t1 NATURAL INNER MERGE JOIN t2
SELECT (a) FROM t1 NATURAL INNER MERGE JOIN t2 -- fully parenthesized
SELECT a FROM t1 NATURAL INNER MERGE JOIN t2 -- literals removed
SELECT _ FROM _ NATURAL INNER MERGE JOIN _ -- identifiers removed

parse
SELECT a FROM t1 INNER JOIN t2 USING (a)
----
SELECT a FROM t1 INNER JOIN t2 USING (a)
SELECT (a) FROM t1 INNER JOIN t2 USING (a) -- fully parenthesized
SELECT a FROM t1 INNER JOIN t2 USING (a) -- literals removed
SELECT _ FROM _ INNER JOIN _ USING (_) -- identifiers removed

parse
SELECT a FROM t1 INNER STRAIGHT JOIN t2 USING (a)
----
SELECT a FROM t1 INNER STRAIGHT JOIN t2 USING (a)
SELECT (a) FROM t1 INNER STRAIGHT JOIN t2 USING (a) -- fully parenthesized
SELECT a FROM t1 INNER STRAIGHT JOIN t2 USING (a) -- literals removed
SELECT _ FROM _ INNER STRAIGHT JOIN _ USING (_) -- identifiers removed

parse
SELECT a FROM t1 FULL JOIN t2 USING (a)
----
SELECT a FROM t1 FULL JOIN t2 USING (a)
SELECT (a) FROM t1 FULL JOIN t2 USING (a) -- fully parenthesized
SELECT a FROM t1 FULL JOIN t2 USING (a) -- literals removed
SELECT _ FROM _ FULL JOIN _ USING (_) -- identifiers removed

parse
SELECT a FROM t1 FULL MERGE JOIN t2 USING (a)
----
SELECT a FROM t1 FULL MERGE JOIN t2 USING (a)
SELECT (a) FROM t1 FULL MERGE JOIN t2 USING (a) -- fully parenthesized
SELECT a FROM t1 FULL MERGE JOIN t2 USING (a) -- literals removed
SELECT _ FROM _ FULL MERGE JOIN _ USING (_) -- identifiers removed

parse
SELECT * FROM (t1 WITH ORDINALITY AS o1 CROSS JOIN t2 WITH ORDINALITY AS o2) WITH ORDINALITY AS o3
----
SELECT * FROM (t1 WITH ORDINALITY AS o1 CROSS JOIN t2 WITH ORDINALITY AS o2) WITH ORDINALITY AS o3
SELECT (*) FROM (t1 WITH ORDINALITY AS o1 CROSS JOIN t2 WITH ORDINALITY AS o2) WITH ORDINALITY AS o3 -- fully parenthesized
SELECT * FROM (t1 WITH ORDINALITY AS o1 CROSS JOIN t2 WITH ORDINALITY AS o2) WITH ORDINALITY AS o3 -- literals removed
SELECT * FROM (_ WITH ORDINALITY AS _ CROSS JOIN _ WITH ORDINALITY AS _) WITH ORDINALITY AS _ -- identifiers removed

parse
SELECT a FROM t1 AS OF SYSTEM TIME '2016-01-01'
----
SELECT a FROM t1 AS OF SYSTEM TIME '2016-01-01'
SELECT (a) FROM t1 AS OF SYSTEM TIME ('2016-01-01') -- fully parenthesized
SELECT a FROM t1 AS OF SYSTEM TIME '_' -- literals removed
SELECT _ FROM _ AS OF SYSTEM TIME '2016-01-01' -- identifiers removed

parse
SELECT a FROM t1, t2 AS OF SYSTEM TIME '2016-01-01'
----
SELECT a FROM t1, t2 AS OF SYSTEM TIME '2016-01-01'
SELECT (a) FROM t1, t2 AS OF SYSTEM TIME ('2016-01-01') -- fully parenthesized
SELECT a FROM t1, t2 AS OF SYSTEM TIME '_' -- literals removed
SELECT _ FROM _, _ AS OF SYSTEM TIME '2016-01-01' -- identifiers removed

parse
SELECT a FROM t1 AS OF SYSTEM TIME -('a' || 'b')::INTERVAL
----
SELECT a FROM t1 AS OF SYSTEM TIME -('a' || 'b')::INTERVAL
SELECT (a) FROM t1 AS OF SYSTEM TIME (-((((('a') || ('b'))))::INTERVAL)) -- fully parenthesized
SELECT a FROM t1 AS OF SYSTEM TIME -('_' || '_')::INTERVAL -- literals removed
SELECT _ FROM _ AS OF SYSTEM TIME -('a' || 'b')::INTERVAL -- identifiers removed

parse
SELECT * FROM t LIMIT ALL
----
SELECT * FROM t LIMIT ALL
SELECT (*) FROM t LIMIT ALL -- fully parenthesized
SELECT * FROM t LIMIT ALL -- literals removed
SELECT * FROM _ LIMIT ALL -- identifiers removed

parse
SELECT EXISTS ((((TABLE error FOR KEY SHARE)) LIMIT ALL FOR KEY SHARE)) AS is FROM ident
----
SELECT EXISTS ((((TABLE error FOR KEY SHARE)) LIMIT ALL FOR KEY SHARE)) AS is FROM ident
SELECT (EXISTS ((((TABLE error FOR KEY SHARE)) LIMIT ALL FOR KEY SHARE))) AS is FROM ident -- fully parenthesized
SELECT EXISTS ((((TABLE error FOR KEY SHARE)) LIMIT ALL FOR KEY SHARE)) AS is FROM ident -- literals removed
SELECT EXISTS ((((TABLE _ FOR KEY SHARE)) LIMIT ALL FOR KEY SHARE)) AS _ FROM _ -- identifiers removed

parse
SELECT a FROM t LIMIT a
----
SELECT a FROM t LIMIT a
SELECT (a) FROM t LIMIT (a) -- fully parenthesized
SELECT a FROM t LIMIT a -- literals removed
SELECT _ FROM _ LIMIT _ -- identifiers removed

parse
SELECT a FROM t OFFSET b
----
SELECT a FROM t OFFSET b
SELECT (a) FROM t OFFSET (b) -- fully parenthesized
SELECT a FROM t OFFSET b -- literals removed
SELECT _ FROM _ OFFSET _ -- identifiers removed

parse
SELECT a FROM t LIMIT a OFFSET b
----
SELECT a FROM t LIMIT a OFFSET b
SELECT (a) FROM t LIMIT (a) OFFSET (b) -- fully parenthesized
SELECT a FROM t LIMIT a OFFSET b -- literals removed
SELECT _ FROM _ LIMIT _ OFFSET _ -- identifiers removed

parse
SELECT a FROM t1 OFFSET a ROW
----
SELECT a FROM t1 OFFSET a -- normalized!
SELECT (a) FROM t1 OFFSET (a) -- fully parenthesized
SELECT a FROM t1 OFFSET a -- literals removed
SELECT _ FROM _ OFFSET _ -- identifiers removed

parse
SELECT a FROM t1 OFFSET a ROWS
----
SELECT a FROM t1 OFFSET a -- normalized!
SELECT (a) FROM t1 OFFSET (a) -- fully parenthesized
SELECT a FROM t1 OFFSET a -- literals removed
SELECT _ FROM _ OFFSET _ -- identifiers removed

parse
SELECT a FROM t OFFSET a LIMIT b
----
SELECT a FROM t LIMIT b OFFSET a -- normalized!
SELECT (a) FROM t LIMIT (b) OFFSET (a) -- fully parenthesized
SELECT a FROM t LIMIT b OFFSET a -- literals removed
SELECT _ FROM _ LIMIT _ OFFSET _ -- identifiers removed

parse
SELECT a FROM t FETCH FIRST 3 ROWS ONLY
----
SELECT a FROM t LIMIT 3 -- normalized!
SELECT (a) FROM t LIMIT (3) -- fully parenthesized
SELECT a FROM t LIMIT _ -- literals removed
SELECT _ FROM _ LIMIT 3 -- identifiers removed

parse
SELECT a FROM t FETCH NEXT 3 ROWS ONLY
----
SELECT a FROM t LIMIT 3 -- normalized!
SELECT (a) FROM t LIMIT (3) -- fully parenthesized
SELECT a FROM t LIMIT _ -- literals removed
SELECT _ FROM _ LIMIT 3 -- identifiers removed

parse
SELECT a FROM t FETCH FIRST ROW ONLY
----
SELECT a FROM t LIMIT 1 -- normalized!
SELECT (a) FROM t LIMIT (1) -- fully parenthesized
SELECT a FROM t LIMIT _ -- literals removed
SELECT _ FROM _ LIMIT 1 -- identifiers removed

parse
SELECT a FROM t FETCH FIRST (2 * a) ROWS ONLY
----
SELECT a FROM t LIMIT (2 * a) -- normalized!
SELECT (a) FROM t LIMIT ((((2) * (a)))) -- fully parenthesized
SELECT a FROM t LIMIT (_ * a) -- literals removed
SELECT _ FROM _ LIMIT (2 * _) -- identifiers removed

parse
SELECT a FROM t OFFSET b FETCH FIRST (2 * a) ROWS ONLY
----
SELECT a FROM t LIMIT (2 * a) OFFSET b -- normalized!
SELECT (a) FROM t LIMIT ((((2) * (a)))) OFFSET (b) -- fully parenthesized
SELECT a FROM t LIMIT (_ * a) OFFSET b -- literals removed
SELECT _ FROM _ LIMIT (2 * _) OFFSET _ -- identifiers removed

parse
SELECT a FROM t FETCH FIRST (2 * a) ROWS ONLY OFFSET b ROWS
----
SELECT a FROM t LIMIT (2 * a) OFFSET b -- normalized!
SELECT (a) FROM t LIMIT ((((2) * (a)))) OFFSET (b) -- fully parenthesized
SELECT a FROM t LIMIT (_ * a) OFFSET b -- literals removed
SELECT _ FROM _ LIMIT (2 * _) OFFSET _ -- identifiers removed

parse
SELECT a FROM t FETCH FIRST $1 ROWS ONLY OFFSET $2 ROWS
----
SELECT a FROM t LIMIT $1 OFFSET $2 -- normalized!
SELECT (a) FROM t LIMIT ($1) OFFSET ($2) -- fully parenthesized
SELECT a FROM t LIMIT $1 OFFSET $1 -- literals removed
SELECT _ FROM _ LIMIT $1 OFFSET $2 -- identifiers removed

parse
SELECT a FROM t FETCH FIRST +3 ROWS ONLY OFFSET +3 ROWS
----
SELECT a FROM t LIMIT 3 OFFSET 3 -- normalized!
SELECT (a) FROM t LIMIT (3) OFFSET (3) -- fully parenthesized
SELECT a FROM t LIMIT _ OFFSET _ -- literals removed
SELECT _ FROM _ LIMIT 3 OFFSET 3 -- identifiers removed

parse
SELECT a FROM t FETCH FIRST -3 ROWS ONLY OFFSET -3 ROWS
----
SELECT a FROM t LIMIT -3 OFFSET -3 -- normalized!
SELECT (a) FROM t LIMIT (-3) OFFSET (-3) -- fully parenthesized
SELECT a FROM t LIMIT _ OFFSET _ -- literals removed
SELECT _ FROM _ LIMIT -3 OFFSET -3 -- identifiers removed

parse
SELECT a FROM t FETCH FIRST +3.0 ROWS ONLY OFFSET +3.0 ROWS
----
SELECT a FROM t LIMIT 3.0 OFFSET 3.0 -- normalized!
SELECT (a) FROM t LIMIT (3.0) OFFSET (3.0) -- fully parenthesized
SELECT a FROM t LIMIT _ OFFSET _ -- literals removed
SELECT _ FROM _ LIMIT 3.0 OFFSET 3.0 -- identifiers removed

parse
SELECT a FROM t FETCH FIRST -3.0 ROWS ONLY OFFSET -3.0 ROWS
----
SELECT a FROM t LIMIT -3.0 OFFSET -3.0 -- normalized!
SELECT (a) FROM t LIMIT (-3.0) OFFSET (-3.0) -- fully parenthesized
SELECT a FROM t LIMIT _ OFFSET _ -- literals removed
SELECT _ FROM _ LIMIT -3.0 OFFSET -3.0 -- identifiers removed



parse
SELECT DISTINCT * FROM t
----
SELECT DISTINCT * FROM t
SELECT DISTINCT (*) FROM t -- fully parenthesized
SELECT DISTINCT * FROM t -- literals removed
SELECT DISTINCT * FROM _ -- identifiers removed

parse
SELECT DISTINCT a, b FROM t
----
SELECT DISTINCT a, b FROM t
SELECT DISTINCT (a), (b) FROM t -- fully parenthesized
SELECT DISTINCT a, b FROM t -- literals removed
SELECT DISTINCT _, _ FROM _ -- identifiers removed

parse
SELECT DISTINCT ON (a, b) c FROM t
----
SELECT DISTINCT ON (a, b) c FROM t
SELECT DISTINCT ON ((a), (b)) (c) FROM t -- fully parenthesized
SELECT DISTINCT ON (a, b) c FROM t -- literals removed
SELECT DISTINCT ON (_, _) _ FROM _ -- identifiers removed

parse
SELECT * FROM (VALUES (1, 2)) AS foo
----
SELECT * FROM (VALUES (1, 2)) AS foo
SELECT (*) FROM ((VALUES ((1), (2)))) AS foo -- fully parenthesized
SELECT * FROM (VALUES (_, _)) AS foo -- literals removed
SELECT * FROM (VALUES (1, 2)) AS _ -- identifiers removed

parse
SELECT * FROM (VALUES (1, 2)) AS foo (a, b)
----
SELECT * FROM (VALUES (1, 2)) AS foo (a, b)
SELECT (*) FROM ((VALUES ((1), (2)))) AS foo (a, b) -- fully parenthesized
SELECT * FROM (VALUES (_, _)) AS foo (a, b) -- literals removed
SELECT * FROM (VALUES (1, 2)) AS _ (_, _) -- identifiers removed

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

parse
SELECT 1 FOR NO KEY UPDATE
----
SELECT 1 FOR NO KEY UPDATE
SELECT (1) FOR NO KEY UPDATE -- fully parenthesized
SELECT _ FOR NO KEY UPDATE -- literals removed
SELECT 1 FOR NO KEY UPDATE -- identifiers removed

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

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

parse
SELECT 1 FOR UPDATE OF a
----
SELECT 1 FOR UPDATE OF a
SELECT (1) FOR UPDATE OF a -- fully parenthesized
SELECT _ FOR UPDATE OF a -- literals removed
SELECT 1 FOR UPDATE OF _ -- identifiers removed

parse
SELECT 1 FOR NO KEY UPDATE OF a, b
----
SELECT 1 FOR NO KEY UPDATE OF a, b
SELECT (1) FOR NO KEY UPDATE OF a, b -- fully parenthesized
SELECT _ FOR NO KEY UPDATE OF a, b -- literals removed
SELECT 1 FOR NO KEY UPDATE OF _, _ -- identifiers removed

parse
SELECT 1 FOR UPDATE SKIP LOCKED
----
SELECT 1 FOR UPDATE SKIP LOCKED
SELECT (1) FOR UPDATE SKIP LOCKED -- fully parenthesized
SELECT _ FOR UPDATE SKIP LOCKED -- literals removed
SELECT 1 FOR UPDATE SKIP LOCKED -- identifiers removed

parse
SELECT 1 FOR NO KEY UPDATE OF a, b NOWAIT
----
SELECT 1 FOR NO KEY UPDATE OF a, b NOWAIT
SELECT (1) FOR NO KEY UPDATE OF a, b NOWAIT -- fully parenthesized
SELECT _ FOR NO KEY UPDATE OF a, b NOWAIT -- literals removed
SELECT 1 FOR NO KEY UPDATE OF _, _ NOWAIT -- identifiers removed

parse
SELECT 1 ORDER BY 1 FOR UPDATE
----
SELECT 1 ORDER BY 1 FOR UPDATE
SELECT (1) ORDER BY (1) FOR UPDATE -- fully parenthesized
SELECT _ ORDER BY _ FOR UPDATE -- literals removed
SELECT 1 ORDER BY 1 FOR UPDATE -- identifiers removed

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

parse
SELECT 1 ORDER BY 1 LIMIT 1 FOR UPDATE
----
SELECT 1 ORDER BY 1 LIMIT 1 FOR UPDATE
SELECT (1) ORDER BY (1) LIMIT (1) FOR UPDATE -- fully parenthesized
SELECT _ ORDER BY _ LIMIT _ FOR UPDATE -- literals removed
SELECT 1 ORDER BY 1 LIMIT 1 FOR UPDATE -- identifiers removed

parse
SELECT 1 ORDER BY 1 FOR UPDATE LIMIT 1
----
SELECT 1 ORDER BY 1 LIMIT 1 FOR UPDATE -- normalized!
SELECT (1) ORDER BY (1) LIMIT (1) FOR UPDATE -- fully parenthesized
SELECT _ ORDER BY _ LIMIT _ FOR UPDATE -- literals removed
SELECT 1 ORDER BY 1 LIMIT 1 FOR UPDATE -- identifiers removed

parse
SELECT 1 FOR READ ONLY
----
SELECT 1 -- normalized!
SELECT (1) -- fully parenthesized
SELECT _ -- literals removed
SELECT 1 -- identifiers removed

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

parse
SELECT 1 FOR SHARE OF a FOR KEY SHARE SKIP LOCKED
----
SELECT 1 FOR SHARE OF a FOR KEY SHARE SKIP LOCKED
SELECT (1) FOR SHARE OF a FOR KEY SHARE SKIP LOCKED -- fully parenthesized
SELECT _ FOR SHARE OF a FOR KEY SHARE SKIP LOCKED -- literals removed
SELECT 1 FOR SHARE OF _ FOR KEY SHARE SKIP LOCKED -- identifiers removed


# regression test: the last "0" once mistakenly lost its quotes

parse
SELECT * FROM "0" JOIN "0" USING (id, "0")
----
SELECT * FROM "0" JOIN "0" USING (id, "0")
SELECT (*) FROM "0" JOIN "0" USING (id, "0") -- fully parenthesized
SELECT * FROM "0" JOIN "0" USING (id, "0") -- literals removed
SELECT * FROM _ JOIN _ USING (_, _) -- identifiers removed

# Regression test for #15926

parse
SELECT * FROM ((t1 NATURAL JOIN t2 WITH ORDINALITY AS o1)) WITH ORDINALITY AS o2
----
SELECT * FROM ((t1 NATURAL JOIN t2 WITH ORDINALITY AS o1)) WITH ORDINALITY AS o2
SELECT (*) FROM ((t1 NATURAL JOIN t2 WITH ORDINALITY AS o1)) WITH ORDINALITY AS o2 -- fully parenthesized
SELECT * FROM ((t1 NATURAL JOIN t2 WITH ORDINALITY AS o1)) WITH ORDINALITY AS o2 -- literals removed
SELECT * FROM ((_ NATURAL JOIN _ WITH ORDINALITY AS _)) WITH ORDINALITY AS _ -- identifiers removed

parse
SELECT * FROM json_to_record('') AS t(a INT, b TEXT, c foo)
----
SELECT * FROM ROWS FROM (json_to_record('')) AS t (a INT8, b STRING, c foo) -- normalized!
SELECT (*) FROM ROWS FROM ((json_to_record(('')))) AS t (a INT8, b STRING, c foo) -- fully parenthesized
SELECT * FROM ROWS FROM (json_to_record('_')) AS t (a INT8, b STRING, c foo) -- literals removed
SELECT * FROM ROWS FROM (_('')) AS _ (_ INT8, _ STRING, _ _) -- identifiers removed

parse
SELECT substring('stringstringstring',1,10) QUERY
----
SELECT substring('stringstringstring', 1, 10) AS query -- normalized!
SELECT (substring(('stringstringstring'), (1), (10))) AS query -- fully parenthesized
SELECT substring('_', _, _) AS query -- literals removed
SELECT substring('stringstringstring', 1, 10) AS _ -- identifiers removed

# Regression UDF identifiers in types in AS clauses

parse
SELECT * FROM json_to_record('') AS t(a "Nice Enum 📙", b TEXT, c foo)
----
SELECT * FROM ROWS FROM (json_to_record('')) AS t (a "Nice Enum 📙", b STRING, c foo) -- normalized!
SELECT (*) FROM ROWS FROM ((json_to_record(('')))) AS t (a "Nice Enum 📙", b STRING, c foo) -- fully parenthesized
SELECT * FROM ROWS FROM (json_to_record('_')) AS t (a "Nice Enum 📙", b STRING, c foo) -- literals removed
SELECT * FROM ROWS FROM (_('')) AS _ (_ _, _ STRING, _ _) -- identifiers removed

parse
SELECT 123 AS OF FROM t
----
SELECT 123 AS of FROM t -- normalized!
SELECT (123) AS of FROM t -- fully parenthesized
SELECT _ AS of FROM t -- literals removed
SELECT 123 AS _ FROM _ -- identifiers removed
