SELECT 1; SELECT 1 AS x; select 1 x; SELECT 'foo'; SELECT ''; SELECT 1 + 2; SELECT 1 + 2 * 3 - 4 / 5 % 6 ^ 7; SELECT 1 < 2, 1 > 2, 1 = 2, 1 <= 2, 1 >= 2, 1 <> 2, 1 != 2; SELECT -1; SELECT +1; SELECT -1.5; SELECT +1.5; SELECT - 1; SELECT -'x'; SELECT -x; SELECT TRUE, FALSE, NULL; SELECT 1.5e10, .5, 0x2A, 0o17, 0b101, 1_000_000; SELECT B'0101'; SELECT X'1F'; SELECT 2147483647, -2147483648, 9999999999; SELECT a FROM b; SELECT a, b FROM c AS d; SELECT a FROM b c; SELECT a FROM b, c, s.t, cat.s.t; SELECT a FROM ONLY b; SELECT a FROM b *; SELECT a FROM ONLY (b); SELECT t.a, t.*, s.t.a FROM t WHERE 1 < 2; SELECT "Quoted Ident" FROM "Tab le"; SELECT abort, absolute; SeLeCt/*c*/1; SELECT (1 + 2) * 3; SELECT ((1)); SELECT $1 + $2; SELECT 1 @+@ 2; SELECT @ 1; SELECT *; SELECT * FROM t; SELECT; SELECT 1; SELECT 2;
SELECT 3 SELECT 1;; SELECT 1 ;; SELECT 2 ;;    -- comment
 SELECT 1 1; SELECT FROM FROM SELECT 1 + SELECT 'foo' 'bar' SELECT
1
1; SELECT a FROM a.b.c.d; SELECT 'unterminated SELECT $$x$$; SELECT E'a\nb'; SELECT e'\x41'; SELECT a, b + 1 FROM t ORDER BY a, b DESC, c ASC NULLS FIRST, d NULLS LAST; SELECT a FROM t ORDER BY a USING < NULLS FIRST, b USING >=; SELECT a FROM t LIMIT 10; SELECT a FROM t LIMIT ALL OFFSET 3; SELECT a FROM t OFFSET 5 LIMIT 2 - 1; SELECT a FROM t ORDER BY a LIMIT 10 OFFSET 2; SELECT a FROM t OFFSET 2 ROWS FETCH FIRST 5 ROWS ONLY; SELECT a FROM t ORDER BY a FETCH NEXT ROW WITH TIES; SELECT a FROM t FETCH FIRST +1 ROW ONLY; SELECT a FROM t ORDER BY a FETCH FIRST -1.5 ROWS WITH TIES; (SELECT a FROM t) ORDER BY a; SELECT a FROM t FOR READ ONLY; SELECT a FROM t FOR READ ONLY LIMIT 2; SELECT count(*) FROM t; SELECT count(a), sum(a + 1), pg_catalog.count(*) FROM t; SELECT f(); SELECT f(a, b ORDER BY c DESC, d); SELECT f(DISTINCT a), f(ALL a, b); SELECT f(VARIADIC a), f(a, VARIADIC b ORDER BY c); SELECT count(*) FILTER (WHERE a > 0) FROM t; SELECT mode() WITHIN GROUP (ORDER BY a) FROM t; SELECT 'x'::text, 1::int8, a::numeric(10, 2), b::pg_catalog.text; SELECT CAST(a AS double precision), CAST(1 + 2 AS bigint), CAST(b AS numeric); SELECT 1::int, 2::integer, 3::smallint, 4::real, 5::dec, 6::decimal(3), 7::boolean, 8::float, 9::float(20), 10::float(30); SELECT B'01'::bit varying, 'c'::char(2), 'v'::varchar(3), 'n'::national character(4), 'x'::bit(2), 'y'::bit, 'z'::character varying; SELECT 'ts'::timestamp(2) with time zone, 't'::time without time zone, 'u'::time(1), 'i'::interval, 'j'::json, 'ts2'::timestamp; SELECT int4 '42', text 'abc', pg_catalog.text 'abc', bpchar 'x', timestamp '2020-01-01', varchar 'v'; SELECT a AND b AND c OR d OR e, NOT NOT a, a OR b AND c; SELECT a IS NULL, b IS NOT NULL, c ISNULL, d NOTNULL, a = 1 AND b IS NULL; SELECT DISTINCT a, b FROM t; SELECT DISTINCT ON (a, b + 1) a FROM t ORDER BY a; SELECT ALL a FROM t; SELECT a FROM t WHERE a = 42; SELECT a FROM t LIMIT 1, 2; (SELECT a FROM t ORDER BY a) ORDER BY b; SELECT a FROM t FETCH FIRST 2 ROWS WITH TIES; SELECT f(a ORDER BY b) WITHIN GROUP (ORDER BY c) FROM t; SELECT f(DISTINCT a) WITHIN GROUP (ORDER BY b) FROM t; SELECT f(VARIADIC a) WITHIN GROUP (ORDER BY b) FROM t; SELECT 1::float(0); SELECT 1::float(60); PREPARE s AS SELECT 1; EXECUTE s; DEALLOCATE s; PREPARE s AS SELECT 1; EXECUTE s; DEALLOCATE s; PREPARE q(int) AS SELECT $1 + 1; PREPARE q (int, text, varchar(10), numeric(8,2)) AS SELECT $1, $2, $3, $4; EXECUTE q(42, 'x'); EXECUTE q (1 + 2 * 3, -4.5, TRUE, NULL); prepare lower_kw as select 'k'; PREPARE "Quoted Name" AS SELECT 2; DEALLOCATE "Quoted Name"; DEALLOCATE PREPARE s; DEALLOCATE ALL; DEALLOCATE PREPARE ALL; PREPARE s SELECT 1; EXECUTE; DEALLOCATE; PREPARE 1 AS SELECT 1; SHOW work_mem; SHOW search_path; SET work_mem = '8MB'; SET datestyle = 'ISO, YMD'; SET search_path TO public; SET LOCAL work_mem = '16MB'; RESET work_mem; RESET datestyle; SET x.y = on; BEGIN; BEGIN WORK; COMMIT; COMMIT WORK; ROLLBACK; SAVEPOINT sp1; ROLLBACK TO SAVEPOINT sp1; RELEASE SAVEPOINT sp1; EXPLAIN (COSTS OFF) SELECT 1; EXPLAIN (ANALYZE, TIMING OFF, SUMMARY OFF, BUFFERS OFF, COSTS OFF) SELECT 1; EXPLAIN (VERBOSE, COSTS OFF) SELECT 1 AS one; SELECT coalesce(NULL, 42); SELECT greatest(1, 2, 3), least(1, 2, 3); SELECT CASE WHEN 1 < 2 THEN 'lt' ELSE 'ge' END; SELECT CASE WHEN a THEN 1 WHEN b THEN 2 ELSE 3 END FROM t; SELECT CASE a WHEN 1 THEN 'one' END FROM t; SELECT * FROM (VALUES (2, 'b'), (1, 'a')) AS v(n, s) ORDER BY n; SELECT x FROM (SELECT 1 AS x) sub; WITH x AS (SELECT 1) SELECT * FROM x WITH RECURSIVE x (a, b) AS MATERIALIZED (SELECT 1, 2), y AS NOT MATERIALIZED (SELECT 3) SELECT a FROM x ORDER BY a LIMIT 2 WITH x AS (SELECT a FROM t WHERE a > 5) SELECT * FROM x, x x2 WITH x AS (SELECT 1) (WITH y AS (SELECT 2) SELECT 1) SELECT 1 SELECT g, row_number() OVER (PARTITION BY g ORDER BY a), rank() OVER (ORDER BY a), sum(a) OVER (PARTITION BY g) FROM t SELECT count(*) OVER w FROM t WINDOW w AS (PARTITION BY g ORDER BY a DESC) SELECT rank() OVER (w ORDER BY a) FROM t WINDOW w AS (PARTITION BY g), v AS (w) SELECT row_number() OVER () FROM t SELECT t1.g FROM t t1 JOIN t t2 ON t1.pk = t2.fk SELECT * FROM a INNER JOIN b ON a.x = b.y; SELECT * FROM a CROSS JOIN b SELECT * FROM (a JOIN b ON a.x = b.x) c SELECT * FROM (a JOIN b ON a.x = b.x) AS c SELECT * FROM a JOIN b ON a.x = b.x JOIN c ON b.y = c.y SELECT * FROM a JOIN (b JOIN c ON b.y = c.y) ON a.x = b.x SELECT * FROM a LEFT JOIN b ON a.x = b.x SELECT * FROM a LEFT OUTER JOIN b ON a.x = b.x SELECT * FROM a RIGHT JOIN b ON true SELECT * FROM a FULL OUTER JOIN b ON a.x = b.x SELECT x.g FROM t x JOIN t y ON x.pk = y.fk WHERE x.g = 5 ORDER BY x.g LIMIT 3 SELECT * FROM a JOIN b DROP TABLE regress_m1_t; DROP TABLE IF EXISTS foo; DROP TABLE a.b, c CASCADE; DROP TABLE IF EXISTS a.b.c, d RESTRICT; drop table "Quoted"."Name"; DROP VIEW v1, v2; DROP SEQUENCE seq1 CASCADE; DROP MATERIALIZED VIEW mv; DROP INDEX idx1; DROP FOREIGN TABLE ft; DROP TEXT SEARCH CONFIGURATION tsc; DROP SCHEMA s1, s2 CASCADE; DROP EXTENSION IF EXISTS ext RESTRICT; DROP TABLE; DROP TABLE IF foo; DROP TABLE a CASCADE RESTRICT; EXPLAIN SELECT 1; EXPLAIN ANALYZE SELECT 1; EXPLAIN ANALYSE VERBOSE SELECT 1; EXPLAIN VERBOSE SELECT 1; EXPLAIN VERBOSE ANALYZE SELECT 1; CREATE INDEX ON t (a); CREATE INDEX i ON t (a, b); CREATE UNIQUE INDEX i ON t (a); CREATE INDEX i ON t (a DESC NULLS LAST, b ASC); CREATE INDEX i ON t USING btree (a); CREATE INDEX IF NOT EXISTS i ON t (a); CREATE INDEX i ON t ((a + b)); CREATE INDEX i ON t (a) WHERE a > 0; CREATE INDEX i ON t (a COLLATE "C"); CREATE INDEX i ON t (a text_pattern_ops); CREATE UNIQUE INDEX CONCURRENTLY i ON t (a); CREATE INDEX i ON t (a) INCLUDE (b); CREATE INDEX i ON t (a) WITH (fillfactor = 70); CREATE INDEX i ON t (a) TABLESPACE ts; CREATE INDEX i ON t (lower(a)); CREATE UNIQUE INDEX i ON t (a) NULLS NOT DISTINCT; CREATE INDEX i ON t (a DESC NULLS FIRST); CREATE INDEX ON; BEGIN; DECLARE c CURSOR FOR SELECT a FROM t ORDER BY a; FETCH 3 c; FETCH NEXT c; FETCH ALL c; CLOSE c; COMMIT; DECLARE c SCROLL CURSOR FOR SELECT 1; DECLARE c2 NO SCROLL CURSOR WITH HOLD FOR SELECT a FROM t DECLARE c BINARY INSENSITIVE SCROLL CURSOR WITHOUT HOLD FOR SELECT * FROM t; DECLARE c3 ASENSITIVE CURSOR FOR SELECT 1 DECLARE "Quoted Cursor" CURSOR FOR SELECT a FROM t WHERE a > 5 ORDER BY a LIMIT 10 FETCH c; FETCH IN c; FETCH FROM c; FETCH NEXT FROM c; FETCH PRIOR FROM c; FETCH FIRST c; FETCH LAST c FETCH ABSOLUTE 7 FROM c; FETCH ABSOLUTE -2 IN c; FETCH RELATIVE -3 c; FETCH 5 FROM c; FETCH -4 c; FETCH ALL c FETCH FORWARD c; FETCH FORWARD 2 c; FETCH FORWARD ALL FROM c; FETCH BACKWARD c; FETCH BACKWARD 2 IN c; FETCH BACKWARD ALL c MOVE c; MOVE 5 c; MOVE BACKWARD ALL FROM c; MOVE ABSOLUTE 3 c; MOVE LAST c; MOVE RELATIVE 2 IN c CLOSE c; CLOSE ALL; close "Quoted Cursor" DECLARE c CURSOR SELECT 1 DECLARE CURSOR FOR SELECT 1 FETCH FORWARD FROM CLOSE SELECT sum(a) OVER (ORDER BY b ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) FROM t SELECT sum(a) OVER (ROWS UNBOUNDED PRECEDING) FROM t SELECT first_value(a) OVER (ORDER BY b RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM t SELECT sum(a) OVER (ORDER BY b ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) FROM t SELECT sum(a) OVER (ORDER BY b GROUPS BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM t SELECT sum(a) OVER (ORDER BY b ROWS BETWEEN 1 FOLLOWING AND 2 FOLLOWING) FROM t SELECT sum(a) OVER (ORDER BY b RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW EXCLUDE CURRENT ROW) FROM t SELECT sum(a) OVER (ORDER BY b ROWS 2 PRECEDING EXCLUDE NO OTHERS) FROM t SELECT sum(a) OVER (ORDER BY b GROUPS BETWEEN 1 PRECEDING AND CURRENT ROW EXCLUDE TIES) FROM t SELECT sum(a) OVER (ORDER BY b RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING EXCLUDE GROUP) FROM t SELECT sum(a) OVER w FROM t WINDOW w AS (PARTITION BY c ORDER BY b ROWS BETWEEN 2 PRECEDING AND 1 PRECEDING) SELECT sum(a) OVER (ORDER BY b RANGE '1 day' PRECEDING) FROM t SELECT sum(a) OVER (ROWS UNBOUNDED FOLLOWING) FROM t SELECT sum(a) OVER (ROWS 1 FOLLOWING) FROM t SELECT sum(a) OVER (ROWS BETWEEN CURRENT ROW AND UNBOUNDED PRECEDING) FROM t SELECT sum(a) OVER (ROWS BETWEEN CURRENT ROW AND 1 PRECEDING) FROM t SELECT sum(a) OVER (ROWS BETWEEN 1 FOLLOWING AND CURRENT ROW) FROM t SELECT sum(a) OVER (ROWS BETWEEN 1 FOLLOWING AND 2 PRECEDING) FROM t ALTER TABLE t ADD COLUMN c int DEFAULT 42; ALTER TABLE t ADD c text; ALTER TABLE t ADD IF NOT EXISTS c int; ALTER TABLE s.t ADD COLUMN IF NOT EXISTS c int; ALTER TABLE IF EXISTS t ADD COLUMN c numeric(8,2) DEFAULT 1 + 2; ALTER TABLE ONLY t ADD COLUMN c int; ALTER TABLE t * ADD COLUMN c int; ALTER TABLE t ADD COLUMN c int NOT NULL; ALTER TABLE t ADD COLUMN c int CHECK (c > 0) DEFAULT 7; ALTER TABLE t ADD COLUMN c int CONSTRAINT dflt DEFAULT 5; ALTER TABLE t DROP COLUMN c; ALTER TABLE t DROP c CASCADE; ALTER TABLE t DROP COLUMN IF EXISTS c RESTRICT; ALTER TABLE IF EXISTS s.t DROP c; alter table "Quoted"."Tab" drop column "Col" cascade; ALTER TABLE t DROP COLUMN c, ADD COLUMN d bigint DEFAULT -1; ALTER TABLE t ADD COLUMN d timestamp DEFAULT 'now'; ALTER TABLE; ALTER TABLE t; ALTER TABLE t DROP COLUMN; ALTER TABLE t ADD COLUMN; ALTER TABLE t ADD COLUMN c; ALTER TABLE t DROP COLUMN c CASCADE RESTRICT; SELECT 1 UNION SELECT 2; SELECT 1 UNION ALL SELECT 2; SELECT 1 INTERSECT SELECT 2; SELECT 1 INTERSECT ALL SELECT 2; SELECT 1 EXCEPT SELECT 2; SELECT 1 EXCEPT ALL SELECT 2; SELECT 1 UNION DISTINCT SELECT 2; SELECT a FROM t UNION SELECT b FROM u EXCEPT SELECT c FROM v; SELECT x FROM t UNION SELECT y FROM u ORDER BY 1 LIMIT 3; (SELECT 1 UNION SELECT 2) INTERSECT SELECT 3; SELECT 1 UNION SELECT 2 INTERSECT SELECT 3; SELECT a FROM t FOR UPDATE SELECT a FROM t FOR UPDATE NOWAIT SELECT a FROM t FOR UPDATE SKIP LOCKED SELECT a FROM t FOR NO KEY UPDATE SELECT a FROM t FOR SHARE SELECT a FROM t FOR KEY SHARE SELECT a FROM t, u FOR UPDATE OF t SELECT a FROM t, u FOR UPDATE OF t, u NOWAIT SELECT a FROM t FOR SHARE OF t FOR UPDATE OF t SELECT a FROM t ORDER BY a LIMIT 1 FOR UPDATE SELECT a FROM t FOR UPDATE LIMIT 1 (SELECT a FROM t) FOR UPDATE SELECT a FROM t WHERE a = 1 FOR UPDATE FOR SHARE NOWAIT SELECT a FROM t FOR KEY SHARE OF s.t SELECT a FROM t ORDER BY a FETCH FIRST 2 ROWS WITH TIES FOR UPDATE SKIP LOCKED SELECT a FROM t FOR UPDATE OF SELECT 1 UNION SELECT 2 FOR UPDATE GRANT SELECT ON t TO PUBLIC; GRANT SELECT, INSERT, UPDATE, DELETE, TRUNCATE, REFERENCES, TRIGGER, MAINTAIN ON TABLE s.t, u TO admin, PUBLIC; GRANT ALL ON t TO r; GRANT ALL PRIVILEGES ON TABLE t TO r; GRANT USAGE ON SEQUENCE sq TO r WITH GRANT OPTION; GRANT SELECT ON t TO CURRENT_USER, CURRENT_ROLE, SESSION_USER, GROUP g; GRANT SELECT ON t TO u GRANTED BY CURRENT_USER; grant select (a, b), references (c) ON t TO u; GRANT ALL (a, b) ON t TO "Quoted Role"; GRANT create ON t TO u; GRANT ALTER SYSTEM ON t TO u; REVOKE SELECT ON t FROM PUBLIC; REVOKE ALL ON TABLE s.t, u FROM admin CASCADE; REVOKE GRANT OPTION FOR SELECT, UPDATE ON t FROM u RESTRICT; REVOKE SELECT ON SEQUENCE sq FROM g GRANTED BY CURRENT_ROLE; REVOKE ALL PRIVILEGES (a) ON t FROM u; GRANT SELECT ON t TO none; GRANT SELECT ON t; select a, b, sum(c) from t group by rollup(a, b); select a, b, sum(c) from t group by cube(a, b); select a, b, sum(c) from t group by grouping sets ((a), (b), ()); select sum(c) from t group by (); select a, grouping(a, b), sum(c) from t group by rollup(a, b); select a from t group by grouping sets (a, rollup(b, c)); select a, b from t group by a, rollup(b, c); select a from t group by distinct rollup(a, b); select grouping(a) from t group by cube(a); select a, b, sum(c) from t group by grouping sets ((a,b)); select a from t group by (a, b); select a from t group by rollup((a,b), c); CREATE TABLE parent (id int PRIMARY KEY); CREATE TABLE child (pid int REFERENCES parent); CREATE TABLE child2 (pid int REFERENCES parent (id) MATCH FULL ON DELETE CASCADE ON UPDATE SET NULL); CREATE TABLE child3 (pid int REFERENCES parent (id) ON UPDATE RESTRICT ON DELETE SET DEFAULT); CREATE TABLE t1 (a int UNIQUE, b int CONSTRAINT nn REFERENCES p (x) MATCH SIMPLE ON DELETE NO ACTION); CREATE TABLE t2 (a int, b int, CONSTRAINT fk_ab FOREIGN KEY (a, b) REFERENCES parent (x, y) ON DELETE SET NULL (a) ON UPDATE CASCADE); CREATE TABLE t3 (a int, b int, FOREIGN KEY (a) REFERENCES parent); CREATE TABLE t4 (a int, b int, PRIMARY KEY (a, b)); CREATE TABLE t5 (a int, b int, UNIQUE NULLS NOT DISTINCT (a) INCLUDE (b)); CREATE TABLE t6 (a int, CONSTRAINT ck CHECK (a > 0)); CREATE TABLE bad1 (pid int REFERENCES parent MATCH PARTIAL); CREATE TABLE bad2 (a int, FOREIGN KEY (a) REFERENCES p ON UPDATE SET NULL (a)); CREATE TABLE bad3 (a int, CONSTRAINT c CHECK (a > 0) DEFERRABLE); CREATE TABLE bad4 (a int, FOREIGN KEY (a) REFERENCES p NOT DEFERRABLE INITIALLY DEFERRED); CREATE TABLE bad5 (a int, FOREIGN KEY (a) REFERENCES p NO INHERIT); CREATE TABLE bad6 (a int, UNIQUE (a) NOT VALID); SELECT 1 WHERE 1 OPERATOR(pg_catalog.=) 1; SELECT 1 FROM ONLY t x WHERE "id" OPERATOR(pg_catalog.=) $1 FOR KEY SHARE OF x; SELECT a LIKE 'x%' FROM t SELECT a NOT LIKE 'x%' FROM t SELECT a LIKE 'x!%' ESCAPE '!' FROM t SELECT a NOT LIKE 'x!%' ESCAPE '!' FROM t SELECT a ILIKE 'x%' FROM t SELECT a NOT ILIKE 'x%' FROM t SELECT a ILIKE 'x!%' ESCAPE '!' FROM t SELECT a NOT ILIKE 'x!%' ESCAPE '!' FROM t SELECT NOT a LIKE 'x%' AND b FROM t SELECT c FROM tchar WHERE c LIKE 'ab%' ORDER BY c SELECT a LIKE b ESCAPE c ILIKE d FROM t SELECT 1 IS DISTINCT FROM 2, a IS NOT DISTINCT FROM NULL; SELECT NULL IS DISTINCT FROM NULL, NULL IS NOT DISTINCT FROM 'x'; SELECT a IS TRUE, b IS NOT TRUE, c IS FALSE, d IS NOT FALSE, e IS UNKNOWN, f IS NOT UNKNOWN FROM t; SELECT a IS NOT TRUE IS FALSE, NOT b IS UNKNOWN; SELECT 'x' COLLATE "C", n COLLATE pg_catalog."default", s COLLATE de_DE FROM t; SELECT a IN (1), b NOT IN (1, 2 + 3, 'x'), c IN (SELECT 1); SELECT 1 = ANY (a), 2 > ALL (b + 1), 3 <> SOME (c); SELECT (1, 2), ROW(1, 2, 3), ROW(1), ROW(), (a, b + 1, 'x'); SELECT (a, b) < (c, d), ROW(x) = ROW(y); SELECT a BETWEEN 1 AND 2, b NOT BETWEEN SYMMETRIC 3 AND 4; SELECT 1 IS DISTINCT 2; SELECT x COLLATE; CREATE SEQUENCE s; CREATE SEQUENCE myschema.seq1 INCREMENT BY 5 START WITH 100; CREATE SEQUENCE IF NOT EXISTS s2 MINVALUE 0 MAXVALUE 1000 CACHE 20 CYCLE; CREATE SEQUENCE s3 AS integer INCREMENT -1 NO MINVALUE NO MAXVALUE NO CYCLE; CREATE SEQUENCE s4 START 9223372036854775807; CREATE SEQUENCE s5 INCREMENT BY -2.5 CACHE 10.5; CREATE SEQUENCE s6 OWNED BY tbl.col; CREATE SEQUENCE s7 SEQUENCE NAME x.y RESTART 5; CREATE SEQUENCE s8 LOGGED UNLOGGED RESTART; CREATE SEQUENCE s9 START WITH +42 MAXVALUE -1 AS pg_catalog.int8; CREATE SEQUENCE; CREATE SEQUENCE s10 WITH 1; CREATE DOMAIN posint AS int CHECK (VALUE > 0) NOT NULL; CREATE DOMAIN d1 AS text create domain myschema.d2 integer default 5 + 1 CREATE DOMAIN d3 AS numeric NULL CHECK (value <> 0) CREATE DOMAIN d4 AS int CONSTRAINT pos CHECK (VALUE > 0) CREATE DOMAIN CREATE TABLE t (a int4); CREATE TABLE pt (a int4, b text) PARTITION BY RANGE (a); CREATE TABLE pt (a int4) PARTITION BY LIST (a, b); create table pt (a int4) partition by hash (a, b); CREATE TABLE pt (a int4) PARTITION BY RANGE ((a + 1), lower(b), c); CREATE TABLE pt (a int4) PARTITION BY RANGE (a COLLATE "C" int4_ops); CREATE TABLE pt (a int4) PARTITION BY foo (a); CREATE TABLE c1 PARTITION OF pt FOR VALUES FROM (1) TO (10); CREATE TABLE c1 PARTITION OF s.pt FOR VALUES FROM (MINVALUE, 0) TO (MAXVALUE, 'x'); CREATE TABLE c2 PARTITION OF pt FOR VALUES IN (1, 2, 3); CREATE TABLE c3 PARTITION OF pt FOR VALUES IN ('a', NULL, true); CREATE TABLE c4 PARTITION OF pt DEFAULT; CREATE TEMP TABLE c5 PARTITION OF pt DEFAULT; CREATE TABLE c6 PARTITION OF pt FOR VALUES FROM (1, 'x') TO (10, 'y') PARTITION BY LIST (b); CREATE TABLE c7 PARTITION OF pt FOR VALUES IN (1) TABLESPACE ts; CREATE TABLE c PARTITION OF pt; SELECT * FROM t x(a, b) SELECT * FROM t AS x(a) SELECT x.a FROM (SELECT 1) x(a) SELECT * FROM (a JOIN b ON true) c(p, q) SELECT * FROM ONLY t x(a, b, c) SELECT g FROM generate_series(1, 3) g(i) SELECT 1 OPERATOR(pg_catalog.+) 2 SELECT 1 OPERATOR(+) 2 SELECT a FROM t ORDER BY a USING OPERATOR(pg_catalog.<) SELECT a FROM t WHERE a OPERATOR(myschema.deep.=) 1 SELECT 1 WHERE 1 OPERATOR(pg_catalog.=) ANY (SELECT 1) TABLE t TABLE ONLY s.t TABLE t ORDER BY a LIMIT 2 ALTER TABLE t ALTER COLUMN c SET DEFAULT 1 + 2 ALTER TABLE t ALTER c DROP DEFAULT ALTER TABLE t ALTER c DROP NOT NULL ALTER TABLE t ALTER COLUMN c SET NOT NULL ALTER TABLE t ALTER c SET EXPRESSION AS (c + 1) ALTER TABLE t ALTER c DROP EXPRESSION ALTER TABLE t ALTER COLUMN c DROP EXPRESSION IF EXISTS ALTER TABLE t ALTER COLUMN c SET STATISTICS 100 ALTER TABLE t ALTER COLUMN c SET STATISTICS DEFAULT ALTER TABLE t ALTER COLUMN 4 SET STATISTICS 55 ALTER TABLE t ALTER COLUMN 0 SET STATISTICS 5 ALTER TABLE t ALTER COLUMN 40000 SET STATISTICS 5 ALTER TABLE t ALTER c SET (n_distinct = 7) ALTER TABLE t ALTER COLUMN c RESET (n_distinct) ALTER TABLE t ALTER c SET STORAGE PLAIN ALTER TABLE t ALTER c SET STORAGE DEFAULT ALTER TABLE t ALTER c SET COMPRESSION lz4 ALTER TABLE t ALTER c SET COMPRESSION DEFAULT ALTER TABLE t ALTER c SET GENERATED ALWAYS ALTER TABLE t ALTER COLUMN c SET GENERATED BY DEFAULT RESTART WITH 10 ALTER TABLE t ALTER c RESTART ALTER TABLE t ALTER c DROP IDENTITY ALTER TABLE t ALTER COLUMN c DROP IDENTITY IF EXISTS ALTER TABLE t ALTER c TYPE text ALTER TABLE t ALTER COLUMN c SET DATA TYPE numeric(10, 2) COLLATE "C" USING c::numeric ALTER TABLE t ALTER c OPTIONS (SET opt 'v', ADD o2 'w', DROP o3) ALTER TABLE t ALTER COLUMN c OPTIONS (o1 'x') ALTER TABLE t VALIDATE CONSTRAINT cc ALTER TABLE t DROP CONSTRAINT IF EXISTS cc CASCADE ALTER TABLE t DROP CONSTRAINT cc ALTER TABLE t SET WITHOUT OIDS ALTER TABLE t CLUSTER ON idx ALTER TABLE t SET WITHOUT CLUSTER ALTER TABLE t SET LOGGED ALTER TABLE t SET UNLOGGED ALTER TABLE t ENABLE TRIGGER tg, ENABLE ALWAYS TRIGGER tg, ENABLE REPLICA TRIGGER tg, ENABLE TRIGGER ALL, ENABLE TRIGGER USER, DISABLE TRIGGER tg, DISABLE TRIGGER ALL, DISABLE TRIGGER USER ALTER TABLE t ENABLE RULE rr, ENABLE ALWAYS RULE rr, ENABLE REPLICA RULE rr, DISABLE RULE rr ALTER TABLE t INHERIT par ALTER TABLE t NO INHERIT s.par ALTER TABLE t OF s.comptype ALTER TABLE t NOT OF ALTER TABLE t OWNER TO alice ALTER TABLE t OWNER TO CURRENT_USER ALTER TABLE t OWNER TO public ALTER TABLE t SET ACCESS METHOD heap2 ALTER TABLE t SET ACCESS METHOD DEFAULT ALTER TABLE t SET TABLESPACE ts ALTER TABLE t SET (fillfactor = 70) ALTER TABLE t RESET (fillfactor) ALTER TABLE t REPLICA IDENTITY NOTHING ALTER TABLE t REPLICA IDENTITY FULL ALTER TABLE t REPLICA IDENTITY DEFAULT ALTER TABLE t REPLICA IDENTITY USING INDEX ridx ALTER TABLE t ENABLE ROW LEVEL SECURITY, DISABLE ROW LEVEL SECURITY, FORCE ROW LEVEL SECURITY, NO FORCE ROW LEVEL SECURITY ALTER TABLE t OPTIONS (ADD foo 'bar') ALTER TABLE IF EXISTS t ALTER c TYPE int4, OWNER TO SESSION_USER, SET (autovacuum_enabled = 'off') CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy'); CREATE TYPE public.empty_mood AS ENUM (); CREATE TYPE s.q.mood3 AS ENUM ('a'); ALTER TYPE mood ADD VALUE 'meh'; ALTER TYPE mood ADD VALUE IF NOT EXISTS 'meh'; ALTER TYPE mood ADD VALUE 'meh' BEFORE 'ok'; ALTER TYPE mood ADD VALUE IF NOT EXISTS 'meh' AFTER 'sad'; ALTER TYPE mood RENAME VALUE 'sad' TO 'blue'; ALTER TYPE mood DROP VALUE 'sad'; CREATE VIEW v1 AS SELECT t1.a, t1.b, t2.d FROM t1 JOIN t2 ON t1.a = t2.a WHERE t1.b > 10 CREATE OR REPLACE VIEW s.v2 (x, y) AS SELECT 1, 2 CREATE VIEW v3 AS SELECT a FROM t WITH CHECK OPTION CREATE VIEW v4 AS SELECT a FROM t WITH CASCADED CHECK OPTION CREATE VIEW v5 AS SELECT a FROM t WITH LOCAL CHECK OPTION create view "Quoted"."Name" as select 1 CREATE VIEW v6 AS SELECT a FROM t ORDER BY a LIMIT 3 CREATE VIEW v AS CREATE VIEW AS SELECT 1 CREATE VIEW v (a,) AS SELECT 1 CREATE MATERIALIZED VIEW mv1 AS SELECT a, b FROM t WHERE a > 1 CREATE MATERIALIZED VIEW IF NOT EXISTS s.mv2 (x, y) AS SELECT 1, 2 WITH NO DATA CREATE UNLOGGED MATERIALIZED VIEW mv3 AS SELECT 1 WITH DATA CREATE MATERIALIZED VIEW mv4 USING heap AS SELECT * FROM t REFRESH MATERIALIZED VIEW mv1 REFRESH MATERIALIZED VIEW CONCURRENTLY s.mv2 REFRESH MATERIALIZED VIEW mv1 WITH NO DATA CREATE MATERIALIZED VIEW AS SELECT 1 DROP MATERIALIZED VIEW IF EXISTS mv1, s.mv2 CASCADE CREATE OPERATOR === (LEFTARG = box, RIGHTARG = box, FUNCTION = area_equal_function, COMMUTATOR = ===, NEGATOR = !==, RESTRICT = area_restriction_function, JOIN = area_join_function, HASHES, MERGES); CREATE OPERATOR myschema.## (leftarg = int4, rightarg = myschema.widget, procedure = myschema.myfn); CREATE OPERATOR @#@ (rightarg = int8, procedure = factorial, commutator = OPERATOR(alt.%>), negator = <>, restrict = '1.5', join = 2, sort1 = <, unknownattr = all) CREATE OPERATOR CLASS widget_ops DEFAULT FOR TYPE widget USING btree FAMILY wf AS OPERATOR 1 <, OPERATOR 2 <=(widget, widget), OPERATOR 5 my.> FOR SEARCH, OPERATOR 4 >< FOR ORDER BY float_ops, FUNCTION 1 btwidgetcmp(widget, widget), FUNCTION 2 (widget, widget) widget_sortsupport(internal), FUNCTION 3 nofn, STORAGE widget; CREATE OPERATOR CLASS oc FOR TYPE int4 USING hash AS FUNCTION 1 hashint4(in x int4, out int4, variadic int8, inout named text); CREATE OPERATOR FAMILY fam USING btree; CREATE OPERATOR FAMILY s.fam USING gist ALTER OPERATOR FAMILY fam USING btree ADD OPERATOR 1 < (int4, int8), FUNCTION 1 btint48cmp(int4, int8); ALTER OPERATOR FAMILY s.fam USING btree DROP OPERATOR 1 (int4, int8), FUNCTION 2 (int4); ALTER OPERATOR === (boolean, boolean) SET (RESTRICT = NONE, JOIN = contjoinsel, COMMUTATOR = ===, HASHES); ALTER OPERATOR my.+ (int4, int4) SET (negator = OPERATOR(my.-), merges) ALTER OPERATOR @@ (int4) SET (restrict = eqsel) CREATE OPERATOR FAMILY; MERGE INTO t USING s ON t.a = s.a WHEN MATCHED THEN UPDATE SET b = s.b WHEN NOT MATCHED THEN INSERT (a, b) VALUES (s.a, s.b); MERGE INTO ONLY t AS tt USING (SELECT 1 AS x) AS ss ON tt.a = ss.x WHEN MATCHED AND tt.b > 0 THEN DELETE WHEN MATCHED THEN DO NOTHING WHEN NOT MATCHED AND ss.x < 4 THEN DO NOTHING; MERGE INTO t USING s ON true WHEN NOT MATCHED BY SOURCE THEN DELETE WHEN NOT MATCHED BY TARGET THEN INSERT DEFAULT VALUES; MERGE INTO t t2 USING s ON t2.k = s.k WHEN MATCHED THEN UPDATE SET b = s.b + 1 WHEN NOT MATCHED THEN INSERT OVERRIDING SYSTEM VALUE VALUES (1, 2) RETURNING t2.a, s.b; MERGE INTO t USING s ON t.a = s.a WHEN NOT MATCHED THEN INSERT (a) OVERRIDING USER VALUE VALUES (s.a); merge into t using s on t.a = s.a when matched then delete; WITH w AS (SELECT 1) MERGE INTO t USING w ON true WHEN MATCHED THEN DELETE; MERGE INTO t USING s ON t.a = s.a; MERGE t USING s ON true WHEN MATCHED THEN DELETE; MERGE INTO t USING s ON true WHEN MATCHED THEN INSERT VALUES (1); PREPARE TRANSACTION 'foo'; COMMIT PREPARED 'foo'; ROLLBACK PREPARED 'foo'; PREPARE TRANSACTION 'gid with ''quote'''; BEGIN; PREPARE TRANSACTION 'x'; COMMIT PREPARED 'x'; ROLLBACK PREPARED 'x' ; COMMIT PREPARED CREATE EXTENSION fixture; CREATE EXTENSION IF NOT EXISTS fixture; CREATE EXTENSION fixture WITH SCHEMA public VERSION '1.0' CASCADE; CREATE EXTENSION fixture SCHEMA myschema; ALTER EXTENSION fixture UPDATE; ALTER EXTENSION fixture UPDATE TO '1.1'; DROP EXTENSION fixture; DROP EXTENSION IF EXISTS fixture, other CASCADE; CREATE TABLE ctas1 AS SELECT a, b FROM t WHERE a > 1 CREATE TABLE IF NOT EXISTS s.ctas2 (x, y) AS SELECT 1, 2 WITH NO DATA CREATE TEMP TABLE ctas3 AS SELECT 1 WITH DATA CREATE LOCAL TEMPORARY TABLE ctas4 AS SELECT * FROM t CREATE TEMPORARY TABLE ctas5 AS SELECT 1 CREATE TEMP TABLE ctas6 ON COMMIT DROP AS SELECT 1 CREATE TABLE ctas7 USING heap AS SELECT 1 SELECT a, b INTO tnew FROM t WHERE a > 1 SELECT 1 INTO TEMPORARY tt1 SELECT 1 INTO TEMP tt2 SELECT 1 INTO LOCAL TEMPORARY tt3 SELECT 1 INTO LOCAL TEMP tt4 SELECT 1 INTO UNLOGGED ut1 SELECT 1 INTO TABLE tab1 CREATE TABLE AS SELECT 1 CREATE TRIGGER t1 BEFORE INSERT ON tab FOR EACH ROW EXECUTE FUNCTION f(); CREATE OR REPLACE TRIGGER t2 AFTER UPDATE OF col1, col2 ON s.tab FOR EACH ROW EXECUTE PROCEDURE f(1, 1.5, 'x', ident); CREATE TRIGGER t3 AFTER INSERT OR UPDATE OR DELETE ON tab EXECUTE FUNCTION f(); CREATE TRIGGER t4 INSTEAD OF INSERT ON v FOR EACH ROW EXECUTE FUNCTION f(); CREATE TRIGGER t5 BEFORE UPDATE ON tab FOR EACH ROW WHEN (OLD.a <> NEW.a) EXECUTE FUNCTION f(); CREATE TRIGGER t6 AFTER TRUNCATE ON tab FOR EACH STATEMENT EXECUTE FUNCTION f(); CREATE TRIGGER t7 AFTER INSERT ON tab REFERENCING NEW TABLE AS newtab FOR EACH ROW EXECUTE FUNCTION f(); CREATE TRIGGER t8 AFTER UPDATE ON tab REFERENCING OLD TABLE AS o NEW TABLE AS n FOR EACH ROW EXECUTE FUNCTION f(); CREATE CONSTRAINT TRIGGER ct1 AFTER INSERT ON tab FROM reftab DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION f(); CREATE CONSTRAINT TRIGGER ct2 AFTER DELETE ON tab FOR EACH ROW EXECUTE FUNCTION s.f('a'); CREATE OR REPLACE CONSTRAINT TRIGGER ct3 AFTER INSERT ON tab FOR EACH ROW EXECUTE FUNCTION f(); CREATE TRIGGER t9 BEFORE INSERT OR INSERT ON tab FOR EACH ROW EXECUTE FUNCTION f(); DROP TRIGGER t1 ON tab; DROP TRIGGER IF EXISTS t1 ON s.tab CASCADE; SET CONSTRAINTS ALL DEFERRED; SET CONSTRAINTS c1, s.c2 IMMEDIATE; ALTER TRIGGER t1 ON tab RENAME TO t2; CREATE ROLE alice LOGIN; CREATE USER bob WITH PASSWORD 'x' CREATEDB; ALTER ROLE alice NOLOGIN; ALTER ROLE alice SET work_mem = '10MB'; DROP ROLE IF EXISTS alice, bob; GRANT alice TO bob WITH ADMIN OPTION GRANTED BY CURRENT_USER; REVOKE alice FROM bob; REASSIGN OWNED BY alice TO bob; DROP OWNED BY alice CASCADE; SET ROLE alice; RESET ROLE; DROP FUNCTION f(int, text), s.g() CASCADE DROP FUNCTION IF EXISTS f DROP FUNCTION f(IN a int, OUT b text, INOUT c bigint, VARIADIC d int) DROP PROCEDURE p(numeric(10,2)) RESTRICT DROP PROCEDURE IF EXISTS s.p(text) DROP ROUTINE r(text) DROP AGGREGATE agg(int), agg2(*) CASCADE DROP AGGREGATE IF EXISTS ord(ORDER BY int, text) DROP FUNCTION IF EXISTS s.f COMMENT ON FUNCTION s.f(int) IS 'c' COMMENT ON FUNCTION f IS NULL COMMENT ON FUNCTION binary IS 'k' COMMENT ON AGGREGATE a(*) IS 'x' COMMENT ON PROCEDURE p(text) IS 'y' COMMENT ON ROUTINE s.r IS 'z' GRANT EXECUTE ON FUNCTION f(int), s.g TO u REVOKE EXECUTE ON PROCEDURE p(int) FROM u CASCADE GRANT ALL ON ROUTINE r TO PUBLIC GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA s, s2 TO u WITH GRANT OPTION REVOKE ALL ON ALL PROCEDURES IN SCHEMA s FROM u GRANT EXECUTE ON ALL ROUTINES IN SCHEMA s TO u ALTER FUNCTION f(int) STRICT IMMUTABLE RESTRICT ALTER PROCEDURE p(text) SECURITY DEFINER ALTER ROUTINE r() COST 100 ALTER FUNCTION f(int) RENAME TO g ALTER AGGREGATE a(int) RENAME TO b ALTER PROCEDURE p RENAME TO q ALTER ROUTINE r(text) RENAME TO r2 ALTER FUNCTION f(int) OWNER TO alice ALTER AGGREGATE a(*) OWNER TO CURRENT_USER ALTER PROCEDURE p() OWNER TO SESSION_USER ALTER ROUTINE r(int) OWNER TO public DROP AGGREGATE a(OUT x int) DROP FUNCTION s.* CREATE POLICY p1 ON t1 USING (a > 1); CREATE POLICY p2 ON s.t2 AS RESTRICTIVE FOR SELECT TO pg_monitor, PUBLIC USING (b = 'x'); CREATE POLICY p3 ON t1 FOR INSERT WITH CHECK (a > 0); CREATE POLICY p4 ON t1 AS PERMISSIVE FOR UPDATE TO CURRENT_USER USING (a > 1) WITH CHECK (a < 10); CREATE POLICY p5 ON t1 FOR DELETE USING (true); CREATE POLICY p6 ON t1 FOR ALL TO SESSION_USER USING (a = 1); ALTER POLICY p1 ON t1 TO PUBLIC; ALTER POLICY p1 ON t1 USING (a > 2) WITH CHECK (a < 5); ALTER POLICY p1 ON t1 RENAME TO p1x; DROP POLICY p1x ON t1; DROP POLICY IF EXISTS nope ON t1 CASCADE; ALTER TABLE t1 ENABLE ROW LEVEL SECURITY; ALTER TABLE t1 DISABLE ROW LEVEL SECURITY; ALTER TABLE t1 FORCE ROW LEVEL SECURITY; ALTER TABLE t1 NO FORCE ROW LEVEL SECURITY; ALTER DOMAIN dpos SET DEFAULT 5 + 2; ALTER DOMAIN s1.dpos DROP DEFAULT; ALTER DOMAIN dpos DROP NOT NULL; ALTER DOMAIN dpos SET NOT NULL; ALTER DOMAIN dpos ADD CONSTRAINT c1 CHECK (VALUE > 0); ALTER DOMAIN dpos ADD CHECK (VALUE <> 42) NOT VALID; ALTER DOMAIN dpos ADD CONSTRAINT nn NOT NULL; ALTER DOMAIN dpos ADD NOT NULL NO INHERIT; ALTER DOMAIN dpos ADD CONSTRAINT c2 CHECK (VALUE > 0) DEFERRABLE; ALTER DOMAIN dpos DROP CONSTRAINT c1 CASCADE; ALTER DOMAIN dpos DROP CONSTRAINT IF EXISTS c1 RESTRICT; ALTER DOMAIN dpos VALIDATE CONSTRAINT c1; ALTER DOMAIN dpos RENAME TO dneg; ALTER DOMAIN s1.dpos RENAME CONSTRAINT a TO b; ALTER DOMAIN dpos SET SCHEMA s2; ALTER DOMAIN dpos OWNER TO some_role; DELETE FROM tt WHERE CURRENT OF c1 UPDATE tt SET t = 'x' WHERE CURRENT OF c1 UPDATE tt SET t = 'x', id = 2 WHERE CURRENT OF "Cur" DELETE FROM ONLY tt WHERE CURRENT OF cur2 UPDATE tt AS a SET t = a.id WHERE CURRENT OF cur3 DELETE FROM tt UPDATE tt SET t = DEFAULT WHERE id = 1 SELECT id FROM tt WHERE ctid = '(0,2)' DELETE FROM tt WHERE CURRENT OF CREATE TABLE ex1 (c box, EXCLUDE USING gist (c WITH &&)); CREATE TABLE ex2 (f1 int, CONSTRAINT ex2c EXCLUDE (f1 WITH =) INITIALLY DEFERRED); CREATE TABLE ex3 (f1 int, f2 int, EXCLUDE ((f1 + 0) WITH OPERATOR(pg_catalog.=)) WHERE (f2 > 0)); CREATE TYPE test_type_exists AS (a int, b text) CREATE TYPE s.ct2 AS (a int, b text COLLATE "C") CREATE TYPE c.s.ct3 AS () CREATE TYPE a.b.c.d AS (x int) SELECT * FROM xmltable('/rows/row' PASSING '<rows/>' COLUMNS a int PATH 'a') SELECT * FROM XMLTABLE('/r/c' PASSING doc COLUMNS a int PATH 'a' DEFAULT 7 NOT NULL, b text NULL, ord FOR ORDINALITY) AS t(x, y, z) SELECT * FROM XMLTABLE(XMLNAMESPACES('http://x.y' AS x, DEFAULT 'http://d.e'), '/x:r' PASSING doc COLUMNS a int) SELECT * FROM t, LATERAL XMLTABLE('/r' PASSING t.d COLUMNS c text PATH 'c') AS u SELECT * FROM XMLTABLE('/r' PASSING d COLUMNS a int foo 42) SELECT * FROM XMLTABLE('/r' PASSING d COLUMNS a int PATH 'x' PATH 'y') SELECT * FROM XMLTABLE('/r' PASSING d COLUMNS a int DEFAULT 1 DEFAULT 2) SELECT * FROM XMLTABLE('/r' PASSING d COLUMNS a int NULL NOT NULL) SELECT xmlconcat('<a/>', '<b/>') SELECT xmlelement(NAME foo) SELECT xmlelement(NAME foo, xmlattributes(1 AS bar, 'b' AS baz)) SELECT xmlelement(NAME foo, 'body', 42) SELECT xmlelement(NAME foo, xmlattributes(v), 'body') SELECT xmlexists('//town' PASSING BY REF '<towns/>' BY REF) SELECT xmlexists('//t' PASSING '<x/>') SELECT xmlexists('//t' PASSING BY VALUE '<x/>' BY VALUE) SELECT xmlforest(a, b AS c) SELECT xmlparse(DOCUMENT '<x/>' PRESERVE WHITESPACE) SELECT xmlparse(CONTENT s STRIP WHITESPACE) SELECT xmlparse(CONTENT s) SELECT xmlpi(NAME php) SELECT xmlpi(NAME php, 'echo $x;') SELECT xmlroot(x, VERSION '1.0', STANDALONE YES) SELECT xmlroot(x, VERSION NO VALUE, STANDALONE NO) SELECT xmlroot(x, VERSION '1.1', STANDALONE NO VALUE) SELECT xmlroot(x, VERSION '1.0') SELECT xmlserialize(CONTENT x AS text) SELECT xmlserialize(DOCUMENT x AS varchar(30) INDENT) SELECT xmlserialize(CONTENT x AS text NO INDENT) SELECT x IS DOCUMENT SELECT x IS NOT DOCUMENT SELECT 1 FROM f() AS t(a int, b numeric(10,2) COLLATE "C") SELECT 1 FROM f() AS (a int) SELECT 1 FROM f() t(a int) SELECT * FROM a JOIN b USING (id); SELECT * FROM a LEFT JOIN b USING (id, name) AS j WHERE j.id > 1; SELECT j.* FROM a FULL OUTER JOIN b USING (id) AS j; SELECT * FROM a NATURAL JOIN b; SELECT * FROM a NATURAL FULL OUTER JOIN b; SELECT * FROM a NATURAL LEFT JOIN b NATURAL JOIN c; SELECT * FROM (a JOIN b USING (id)) c; SELECT * FROM a RIGHT JOIN b USING (id) JOIN d ON a.x = d.x; WITH RECURSIVE t(a, b) AS (SELECT 1, 2 UNION ALL SELECT a + 1, b FROM t) SEARCH DEPTH FIRST BY a SET seq SELECT * FROM t; WITH RECURSIVE t(a, b) AS (SELECT 1, 2 UNION ALL SELECT a + 1, b FROM t) SEARCH BREADTH FIRST BY a, b SET ordercol SELECT * FROM t; WITH RECURSIVE t(a) AS (SELECT 1 UNION ALL SELECT a + 1 FROM t) CYCLE a SET is_cycle USING path SELECT * FROM t; WITH RECURSIVE t(a) AS (SELECT 1 UNION ALL SELECT a + 1 FROM t) CYCLE a SET m TO 'Y' DEFAULT 'N' USING p SELECT * FROM t; WITH RECURSIVE t(a) AS (SELECT 1 UNION ALL SELECT a + 1 FROM t) CYCLE a SET m TO 1 DEFAULT 0 USING p SELECT * FROM t; WITH RECURSIVE t(a) AS (SELECT 1 UNION ALL SELECT a + 1 FROM t) CYCLE a SET m TO true DEFAULT false USING p SELECT * FROM t; WITH RECURSIVE t(a, b) AS (SELECT 1, 2 UNION ALL SELECT a + 1, b FROM t) SEARCH DEPTH FIRST BY b, a SET seq CYCLE a, b SET m USING p SELECT * FROM t; WITH RECURSIVE t(a) AS (SELECT 1 UNION ALL SELECT a + 1 FROM t) SEARCH BREADTH FIRST BY "Aa" SET "Seq" SELECT * FROM t; WITH t AS (SELECT 1 AS a) SEARCH DEPTH FIRST BY a SET seq SELECT * FROM t; WITH RECURSIVE t(a) AS (SELECT 1 UNION ALL SELECT a + 1 FROM t) SEARCH DEPTH BY a SET seq SELECT * FROM t; WITH RECURSIVE t(a) AS (SELECT 1 UNION ALL SELECT a + 1 FROM t) CYCLE a SET m TO 1 USING p SELECT * FROM t; WITH RECURSIVE t(a) AS (SELECT 1 UNION ALL SELECT a + 1 FROM t) CYCLE SET m USING p SELECT * FROM t; SET XML OPTION DOCUMENT SET XML OPTION CONTENT SET SESSION XML OPTION DOCUMENT DO $$begin null; end$$ DO LANGUAGE plpgsql $$begin null; end$$ DO $do$ x $do$ LANGUAGE plpgsql CREATE EVENT TRIGGER et1 ON ddl_command_start EXECUTE FUNCTION etfn() CREATE EVENT TRIGGER et2 ON ddl_command_end WHEN TAG IN ('CREATE TABLE', 'drop table') EXECUTE FUNCTION s.etfn() CREATE EVENT TRIGGER et3 ON sql_drop WHEN tag IN ('DROP VIEW') AND other IN ('x', 'y') EXECUTE PROCEDURE etfn() ALTER EVENT TRIGGER et1 ENABLE ALTER EVENT TRIGGER et1 ENABLE REPLICA ALTER EVENT TRIGGER et1 ENABLE ALWAYS ALTER EVENT TRIGGER et1 DISABLE DROP EVENT TRIGGER et1 DROP EVENT TRIGGER IF EXISTS nosuch CASCADE SELECT JSON_OBJECT(); SELECT JSON_OBJECT(RETURNING json); SELECT JSON_OBJECT(RETURNING jsonb); SELECT JSON_OBJECT(RETURNING text); SELECT JSON_OBJECT('a': 1); SELECT JSON_OBJECT('a' VALUE 1); SELECT JSON_OBJECT('a': 1, 'b': 'two', 'c': true, 'd': NULL); SELECT JSON_OBJECT('a': 1, 'b': 'two' RETURNING jsonb); SELECT JSON_OBJECT('a': NULL NULL ON NULL); SELECT JSON_OBJECT('a': NULL ABSENT ON NULL); SELECT JSON_OBJECT('a': NULL ABSENT ON NULL RETURNING jsonb); SELECT JSON_OBJECT('a': 1, 'a': 2); SELECT JSON_OBJECT('a': 1, 'a': 2 RETURNING jsonb); SELECT JSON_OBJECT('a': 1 WITH UNIQUE KEYS RETURNING jsonb); SELECT JSON_OBJECT('a': 1, 'a': 2 WITH UNIQUE KEYS RETURNING jsonb); SELECT JSON_OBJECT('a': JSON_OBJECT('b': 2), 'c': 3); SELECT JSON_OBJECT('a': '{"x":1}'::json, 'b': '{"y":2}'::jsonb); SELECT JSON_OBJECT('k': 1.5, 'l': '2026-01-02'::date); SELECT JSON_OBJECT(NULL: 1); SELECT pg_typeof(JSON_OBJECT()), pg_typeof(JSON_OBJECT(RETURNING jsonb)), pg_typeof(JSON_OBJECT(RETURNING text)); SELECT JSON_OBJECT('{a,1,b,2}'); SELECT JSON_ARRAY(); SELECT JSON_ARRAY(RETURNING jsonb); SELECT JSON_ARRAY(1, 'two', true, NULL); SELECT JSON_ARRAY(1, NULL, 2 NULL ON NULL); SELECT JSON_ARRAY(1, NULL, 2 ABSENT ON NULL); SELECT JSON_ARRAY(1, NULL, 2 RETURNING jsonb); SELECT JSON_ARRAY(1, NULL, 2 NULL ON NULL RETURNING jsonb); SELECT JSON_ARRAY('{"a":1}'::json, '[2]'::jsonb); SELECT JSON_ARRAY(JSON_ARRAY(1,2), JSON_OBJECT('a': 3)); SELECT JSON('{"a": 1}'); SELECT JSON('  {"a" : 1 }  '); SELECT JSON('{"a": 1}' RETURNING jsonb); SELECT JSON('{"a": 1, "a": 2}' WITH UNIQUE KEYS RETURNING jsonb); SELECT JSON('{"a": 1}'::jsonb); SELECT JSON(NULL::text); SELECT JSON('not json'); SELECT JSON_SCALAR(1); SELECT JSON_SCALAR(1.5); SELECT JSON_SCALAR('a "quoted" string'); SELECT JSON_SCALAR(true); SELECT JSON_SCALAR(NULL); SELECT JSON_SCALAR(NULL::int); SELECT JSON_SCALAR(1 RETURNING jsonb); SELECT JSON_SERIALIZE('{"a": 1}'); SELECT JSON_SERIALIZE('{"a": 1}'::jsonb); SELECT pg_typeof(JSON_SERIALIZE('1')); SELECT '{"a":1}' IS JSON, '[1]' IS JSON, '1' IS JSON, 'oops' IS JSON; SELECT '{"a":1}' IS NOT JSON, 'oops' IS NOT JSON; SELECT '{"a":1}' IS JSON VALUE, '{"a":1}' IS JSON OBJECT, '{"a":1}' IS JSON ARRAY, '{"a":1}' IS JSON SCALAR; SELECT '[1,2]' IS JSON OBJECT, '[1,2]' IS JSON ARRAY, '"x"' IS JSON SCALAR, '12' IS JSON SCALAR; SELECT '{"a":1,"a":2}' IS JSON WITHOUT UNIQUE KEYS; SELECT '{"a":1}'::json IS JSON OBJECT; SELECT '{"a":1}'::jsonb IS JSON, '[1]'::jsonb IS JSON ARRAY, '1'::jsonb IS JSON SCALAR, '{"a":1}'::jsonb IS JSON SCALAR; SELECT NULL::text IS JSON, NULL::jsonb IS NOT JSON; SELECT 1::int IS JSON; SELECT JSON_OBJECTAGG(k: v) FROM sqljson_t; SELECT JSON_OBJECTAGG(k VALUE v) FROM sqljson_t; SELECT JSON_OBJECTAGG(k: v NULL ON NULL) FROM sqljson_t; SELECT JSON_OBJECTAGG(k: v ABSENT ON NULL) FROM sqljson_t; SELECT JSON_OBJECTAGG(k: v RETURNING jsonb) FROM sqljson_t; SELECT JSON_OBJECTAGG(k: v ABSENT ON NULL RETURNING jsonb) FROM sqljson_t; SELECT JSON_OBJECTAGG(k: v) FILTER (WHERE v > 1) FROM sqljson_t; SELECT JSON_ARRAYAGG(v) FROM sqljson_t; SELECT JSON_ARRAYAGG(v NULL ON NULL) FROM sqljson_t; SELECT JSON_ARRAYAGG(v ABSENT ON NULL) FROM sqljson_t; SELECT JSON_ARRAYAGG(v ORDER BY v DESC NULLS LAST) FROM sqljson_t; SELECT JSON_ARRAYAGG(v RETURNING jsonb) FROM sqljson_t; SELECT JSON_ARRAYAGG(v ORDER BY k DESC ABSENT ON NULL RETURNING jsonb) FROM sqljson_t; SELECT k, JSON_ARRAYAGG(v) FROM sqljson_t GROUP BY k ORDER BY k; SELECT JSON_OBJECT(k: v) FROM sqljson_t ORDER BY k; SELECT JSON_ARRAY(k, v) FROM sqljson_t ORDER BY k; SELECT pg_get_viewdef('sqljson_v'::regclass); SELECT * FROM sqljson_v ORDER BY o::text; SELECT JSON_OBJECT(1: 1); SELECT JSON_OBJECT('a': 1 RETURNING int); SELECT JSON_SERIALIZE('{"a":1}' RETURNING int); SELECT JSON('{"a":1}' RETURNING int); SELECT JSON_SCALAR(1 RETURNING text); SELECT JSON_ARRAYAGG(v RETURNING int) FROM sqljson_t; SELECT JSON_OBJECT('a': 1) IS JSON OBJECT; SELECT JSON_OBJECT('a': 1) AS explicit_name; SELECT JSON_OBJECT('a': 1); SELECT JSON_ARRAY(1); SELECT JSON('1'); SELECT JSON_SCALAR(1); SELECT JSON_SERIALIZE('1'); SELECT JSON_OBJECTAGG('a': 1); SELECT JSON_ARRAYAGG(1); SELECT JSON_QUERY(jsonb '{"a":[1]}', '$.a' WITH WRAPPER KEEP QUOTES); SELECT JSON_EXISTS(jsonb '{}', '$' PASSING 1 AS x TRUE ON ERROR); SELECT JSON_VALUE(jsonb '"1"', '$' RETURNING int DEFAULT 2 ON ERROR); CREATE TABLE t (a int) PARTITION BY HASH (a) CREATE TABLE c PARTITION OF t FOR VALUES WITH (MODULUS 4, REMAINDER 0) CREATE TABLE c PARTITION OF t FOR VALUES WITH (MODULUS 4) CREATE TABLE c PARTITION OF t FOR VALUES WITH (REMAINDER 0) CREATE TABLE c PARTITION OF t FOR VALUES WITH (MODULUS 4, MODULUS 8) CREATE TABLE c PARTITION OF t FOR VALUES WITH (MODULUS 4, bucket 1) ALTER TABLE p ATTACH PARTITION c FOR VALUES IN (1) ALTER TABLE p ATTACH PARTITION c FOR VALUES FROM (1) TO (2) ALTER TABLE p ATTACH PARTITION c FOR VALUES WITH (MODULUS 2, REMAINDER 1) ALTER TABLE p ATTACH PARTITION c DEFAULT ALTER TABLE IF EXISTS p ATTACH PARTITION c FOR VALUES IN (1) ALTER TABLE p DETACH PARTITION c ALTER TABLE p DETACH PARTITION c CONCURRENTLY ALTER TABLE p DETACH PARTITION c FINALIZE ALTER INDEX pi ATTACH PARTITION ci ALTER TABLE p ATTACH PARTITION ALTER TABLE p DETACH PARTITION c FINALIZE CONCURRENTLY CREATE TABLE rt (i int4) WITH (fillfactor=30, autovacuum_enabled = false, toast.autovacuum_enabled = off, toast.vacuum_truncate); CREATE TABLE rt2 (i int4) WITH (oids = false); CREATE INDEX i ON t (a) WITH (deduplicate_items = off, buffering = auto, foo.bar = none); ALTER INDEX i SET (fillfactor = 40); ALTER INDEX IF EXISTS i RESET (fillfactor); ALTER TABLE t SET (vacuum_index_cleanup = 'auto', fillfactor); CREATE TABLE rt3 (i int4) WITH (ff = -30.1, gg = +4.5, hh = 2) CREATE TABLE rt5 (i int4) WITH (a.b.c = 1) CREATE INDEX i ON t (a) WITH (x = ===, y = pg_catalog.text) GRANT CONNECT, TEMPORARY ON DATABASE d1, d2 TO u1 WITH GRANT OPTION; REVOKE ALL ON DATABASE d1 FROM PUBLIC CASCADE; GRANT USAGE ON DOMAIN s.dom1, dom2 TO u1; REVOKE GRANT OPTION FOR USAGE ON DOMAIN dom1 FROM u1 RESTRICT; GRANT USAGE ON LANGUAGE plpgsql, sql TO u1, PUBLIC; REVOKE USAGE ON LANGUAGE sql FROM CURRENT_USER; GRANT SELECT, UPDATE ON LARGE OBJECT 1234, 42 TO u1; GRANT ALL ON LARGE OBJECT 3000000000 TO PUBLIC; REVOKE SELECT ON LARGE OBJECT 7 FROM u1 CASCADE; GRANT USAGE, CREATE ON SCHEMA s1, s2 TO u1 WITH GRANT OPTION; REVOKE ALL PRIVILEGES ON SCHEMA public FROM PUBLIC; GRANT USAGE ON TYPE int4, pg_catalog.text TO u1 GRANTED BY SESSION_USER; REVOKE USAGE ON TYPE t1 FROM u1, u2 RESTRICT; GRANT ALL ON DATABASE d1 TO SESSION_USER; ALTER TABLE t ADD CONSTRAINT cc CHECK (a > 0) NOT VALID ALTER TABLE t ADD CONSTRAINT cc2 CHECK (a > 0) NOT VALID NO INHERIT ALTER TABLE t ADD CONSTRAINT nn NOT NULL a NOT VALID ALTER TABLE t ADD CONSTRAINT nn2 NOT NULL a NO INHERIT ALTER TABLE t ADD CONSTRAINT fk FOREIGN KEY (a) REFERENCES p (b) NOT VALID ALTER TABLE t ADD CONSTRAINT fk2 FOREIGN KEY (a) REFERENCES p NOT VALID CREATE TABLE tnv (a int, CONSTRAINT cc CHECK (a > 0) NOT VALID) ALTER TABLE t ADD CONSTRAINT uq UNIQUE (a) NOT VALID ALTER TABLE t ADD CONSTRAINT pk PRIMARY KEY (a) NOT VALID ALTER TABLE t ADD CONSTRAINT cc3 CHECK (a > 0) ENFORCED NOT ENFORCED ALTER TABLE ONLY t VALIDATE CONSTRAINT cc ALTER TABLE t ADD CONSTRAINT cc4 CHECK (a > 0) NOT VALID NOT VALID CREATE TABLE badnv (a int NOT NULL NOT VALID) ALTER TABLE t ALTER COLUMN c ADD GENERATED ALWAYS AS IDENTITY ALTER TABLE t ALTER c ADD GENERATED BY DEFAULT AS IDENTITY (START WITH 10 INCREMENT BY 2) COMMENT ON TABLE tc IS 'table doc' COMMENT ON COLUMN tc.a IS 'col doc' COMMENT ON VIEW vv IS NULL COMMENT ON MATERIALIZED VIEW mv IS 'm' COMMENT ON INDEX ii IS 'i' COMMENT ON SEQUENCE s.sq IS 'q' COMMENT ON FOREIGN TABLE ft IS 'f' COMMENT ON COLLATION "C" IS 'c' COMMENT ON CONVERSION cnv IS 'c' COMMENT ON STATISTICS stx IS 's' COMMENT ON TEXT SEARCH PARSER tsp IS 'p' COMMENT ON TEXT SEARCH DICTIONARY tsd IS 'd' COMMENT ON TEXT SEARCH TEMPLATE tst IS 't' COMMENT ON TEXT SEARCH CONFIGURATION tsc IS 'c' COMMENT ON DATABASE db IS 'd' COMMENT ON ROLE rr IS 'r' COMMENT ON SUBSCRIPTION sub IS 's' COMMENT ON TABLESPACE tsp2 IS 't' COMMENT ON ACCESS METHOD gin IS 'a' COMMENT ON EVENT TRIGGER evt IS 'e' COMMENT ON EXTENSION ext IS 'e' COMMENT ON FOREIGN DATA WRAPPER fdw IS 'f' COMMENT ON LANGUAGE plfoo IS 'l' COMMENT ON PROCEDURAL LANGUAGE plbar IS 'l' COMMENT ON PUBLICATION pb IS 'p' COMMENT ON SCHEMA sch IS 's' COMMENT ON SERVER srv IS 's' COMMENT ON TYPE int4 IS 't'; COMMENT ON TYPE s.custom IS 't'; COMMENT ON DOMAIN dom IS 'd' COMMENT ON AGGREGATE myavg(int4) IS 'a'; COMMENT ON AGGREGATE cnt(*) IS 'a'; COMMENT ON AGGREGATE two(int4, text) IS 'a' COMMENT ON FUNCTION f(int4, text) IS 'f'; COMMENT ON FUNCTION f() IS 'f'; COMMENT ON FUNCTION f IS 'f'; COMMENT ON FUNCTION s.f IS 'f' COMMENT ON OPERATOR + (int4, int4) IS 'o'; COMMENT ON OPERATOR pg_catalog.= (int4, int4) IS 'o' COMMENT ON CONSTRAINT cc ON tc IS 'c'; COMMENT ON CONSTRAINT dc ON DOMAIN dom IS 'c' COMMENT ON POLICY pol ON tc IS 'p'; COMMENT ON RULE rul ON tc IS 'r'; COMMENT ON TRIGGER trg ON tc IS 't' COMMENT ON PROCEDURE pr(int4) IS 'p'; COMMENT ON ROUTINE rt(int4) IS 'r' COMMENT ON TRANSFORM FOR int4 LANGUAGE sql IS 't' COMMENT ON OPERATOR CLASS oc USING btree IS 'o'; COMMENT ON OPERATOR FAMILY fam USING btree IS 'o' COMMENT ON LARGE OBJECT 1234 IS 'l'; COMMENT ON LARGE OBJECT 4294967295 IS 'l' COMMENT ON CAST (int4 AS int8) IS 'c' COMMENT ON TABLE tc IS '' COMMENT ON COMMENT ON TABLE COMMENT ON TABLE tc IS COMMENT ON COLUMN a IS 'x' CREATE PUBLICATION p1; CREATE PUBLICATION p1 WITH (publish = 'insert, update'); CREATE PUBLICATION p2 FOR ALL TABLES; CREATE PUBLICATION p2 FOR ALL TABLES WITH (publish_via_partition_root = true); CREATE PUBLICATION p3 FOR TABLE t1; CREATE PUBLICATION p4 FOR TABLE t1 (a, b) WHERE (a > 5); CREATE PUBLICATION p5 FOR TABLES IN SCHEMA s1; CREATE PUBLICATION p6 FOR TABLES IN SCHEMA CURRENT_SCHEMA; CREATE PUBLICATION p7 FOR TABLE t1, s1.t2, t3 (x) WHERE (x < 3), t4; CREATE PUBLICATION p8 FOR TABLE ONLY t1, ONLY (t2), t3 *; CREATE PUBLICATION p9 FOR TABLES IN SCHEMA s1, s2, CURRENT_SCHEMA; CREATE PUBLICATION p10 FOR TABLE t1, TABLES IN SCHEMA s1, TABLE c.s.t2 WITH (publish = 'insert'); CREATE PUBLICATION e1 FOR t1; CREATE PUBLICATION e2 FOR TABLE t1, CURRENT_SCHEMA; CREATE PUBLICATION e3 FOR TABLES IN SCHEMA s1, t1 WHERE (a > 0); CREATE PUBLICATION e4 FOR TABLES IN SCHEMA s1, t1 (a); CREATE PUBLICATION e5 FOR TABLES IN SCHEMA s1, s2.t3; ALTER PUBLICATION p1 SET (publish = 'insert'); ALTER PUBLICATION p1 ADD TABLE t1, s.t2; ALTER PUBLICATION p1 SET TABLE t1 (a) WHERE (a = 1), TABLES IN SCHEMA s2; ALTER PUBLICATION p1 DROP TABLE t1, TABLES IN SCHEMA s1; CREATE SUBSCRIPTION sub1 CONNECTION 'dbname=foo host=bar' PUBLICATION p1, p2 WITH (connect = false, slot_name = 'x'); ALTER SUBSCRIPTION sub1 SET (slot_name = 'y'); ALTER SUBSCRIPTION sub1 CONNECTION 'dbname=baz'; ALTER SUBSCRIPTION sub1 REFRESH PUBLICATION; ALTER SUBSCRIPTION sub1 REFRESH PUBLICATION WITH (copy_data = false); ALTER SUBSCRIPTION sub1 ADD PUBLICATION p3 WITH (refresh = false); ALTER SUBSCRIPTION sub1 DROP PUBLICATION p3; ALTER SUBSCRIPTION sub1 SET PUBLICATION p4, p5; ALTER SUBSCRIPTION sub1 ENABLE; ALTER SUBSCRIPTION sub1 DISABLE; ALTER SUBSCRIPTION sub1 SKIP (lsn = '0/12345'); DROP SUBSCRIPTION sub1; DROP SUBSCRIPTION IF EXISTS sub1 CASCADE; DROP SUBSCRIPTION sub1 RESTRICT; ALTER PUBLICATION pub1 RENAME TO pub2; ALTER SUBSCRIPTION sub1 RENAME TO sub2; ALTER PUBLICATION pub1 OWNER TO regress_owner; ALTER SUBSCRIPTION sub1 OWNER TO CURRENT_USER; ALTER DEFAULT PRIVILEGES GRANT SELECT ON TABLES TO PUBLIC; ALTER DEFAULT PRIVILEGES IN SCHEMA s1, s2 GRANT SELECT, UPDATE ON SEQUENCES TO r WITH GRANT OPTION; ALTER DEFAULT PRIVILEGES FOR ROLE r1, r2 REVOKE EXECUTE ON FUNCTIONS FROM PUBLIC CASCADE; ALTER DEFAULT PRIVILEGES FOR USER u REVOKE GRANT OPTION FOR USAGE ON TYPES FROM r RESTRICT; ALTER DEFAULT PRIVILEGES GRANT ALL ON ROUTINES TO r; ALTER DEFAULT PRIVILEGES GRANT USAGE ON SCHEMAS TO "Quoted Role"; ALTER DEFAULT PRIVILEGES GRANT SELECT, UPDATE ON LARGE OBJECTS TO r; ALTER DEFAULT PRIVILEGES IN SCHEMA s FOR ROLE r GRANT INSERT ON TABLES TO PUBLIC; ALTER DEFAULT PRIVILEGES FOR ROLE r IN SCHEMA s REVOKE ALL PRIVILEGES ON TABLES FROM u; alter default privileges grant all privileges on functions to current_role ALTER DEFAULT PRIVILEGES GRANT SELECT ON TABLES ALTER DEFAULT PRIVILEGES IN SCHEMA GRANT SELECT ON TABLES TO r CREATE TEXT SEARCH DICTIONARY ispell (Template=ispell, DictFile=ispell_sample, AffFile=ispell_sample); CREATE TEXT SEARCH DICTIONARY synonym (Template=synonym, Synonyms=synonym_sample); CREATE TEXT SEARCH DICTIONARY thesaurus (Template=thesaurus, DictFile=thesaurus_sample, Dictionary=english_stem); CREATE TEXT SEARCH DICTIONARY tsdict_case (Template = ispell, "DictFile" = ispell_sample, "AffFile" = ispell_sample); create text search dictionary s.d2 (template = simple, stopwords = english, accept = false); CREATE TEXT SEARCH CONFIGURATION ispell_tst (COPY=english); CREATE TEXT SEARCH CONFIGURATION cfg (PARSER = pg_catalog."default"); CREATE TEXT SEARCH PARSER prs (START=prsd_start, GETTOKEN=prsd_nexttoken, END=prsd_end, LEXTYPES=prsd_lextype, HEADLINE=prsd_headline); CREATE TEXT SEARCH TEMPLATE tmpl (INIT=dsimple_init, LEXIZE=dsimple_lexize); CREATE TEXT SEARCH TEMPLATE t2 (lexize = dsimple_lexize, weird = <=); ALTER TEXT SEARCH DICTIONARY synonym (CaseSensitive = 1); ALTER TEXT SEARCH DICTIONARY synonym (CaseSensitive = 2); ALTER TEXT SEARCH DICTIONARY synonym (CaseSensitive = off); ALTER TEXT SEARCH DICTIONARY d (DictFile = ispell_sample, AffFile = NONE); ALTER TEXT SEARCH CONFIGURATION ispell_tst ALTER MAPPING FOR word, numword, asciiword, hword, numhword, asciihword, hword_part, hword_numpart, hword_asciipart WITH ispell, english_stem; ALTER TEXT SEARCH CONFIGURATION hunspell_tst ALTER MAPPING REPLACE ispell WITH hunspell; ALTER TEXT SEARCH CONFIGURATION t ALTER MAPPING FOR word REPLACE a.b WITH c.d; ALTER TEXT SEARCH CONFIGURATION dummy_tst ADD MAPPING FOR word, word WITH ispell; ALTER TEXT SEARCH CONFIGURATION dummy_tst DROP MAPPING FOR not_a_token, not_a_token; ALTER TEXT SEARCH CONFIGURATION dummy_tst DROP MAPPING IF EXISTS FOR word, word; DROP TEXT SEARCH DICTIONARY ispell; DROP TEXT SEARCH DICTIONARY IF EXISTS foo CASCADE; DROP TEXT SEARCH TEMPLATE tmpl; DROP TEXT SEARCH PARSER prs RESTRICT; CREATE TEXT SEARCH DICTIONARY d; CREATE TEXT SEARCH DICTIONARY d (); ALTER TEXT SEARCH CONFIGURATION c ALTER MAPPING WITH; SELECT ARRAY['a','b','c']; SELECT ARRAY[1, 2+3, NULL]; SELECT ARRAY[ARRAY[1,2], ARRAY[3,4]]; SELECT ARRAY[[1,2],[3,4]]; SELECT ARRAY[]; SELECT ARRAY['']; SELECT ts_delete('base'::tsvector, ARRAY['spaceship','rebel']); SELECT setweight('a'::tsvector, 'c', '{a}') , ARRAY[ARRAY[[1]]]; CREATE TYPE hash_test_t1 AS (a int, b text); CREATE TYPE s.t AS (); CREATE TYPE t2 AS (a numeric(10,2) COLLATE "C", b varchar(3)); CREATE TYPE t AS (a); DROP TYPE hash_test_t1; DROP TYPE IF EXISTS a.b, c CASCADE; DROP DOMAIN d1 RESTRICT; DROP DOMAIN IF EXISTS d2; SELECT jsonb_path_exists(t, p, '{}', silent => true) FROM j SELECT f(1, silent := true) SELECT * FROM generate_series(1,3) WITH ORDINALITY SELECT * FROM generate_series(1,3) WITH ORDINALITY AS t(v, o) SELECT * FROM ROWS FROM (f() AS (a int, b text), g()) WITH ORDINALITY AS t(x, y, z, o) SELECT * FROM ROWS FROM (generate_series(1,2), generate_series(1,3)) SELECT * FROM f() AS t(a int, b text COLLATE "C") SELECT * FROM f() AS (a int) SELECT * FROM f() t(a int) SELECT * FROM unnest(ARRAY[1,2], ARRAY['a','b']) SELECT COLLATION FOR ('x'::text) SELECT NORMALIZE(u), NORMALIZE(u, NFKC) FROM t SELECT OVERLAY(s PLACING 'x' FROM 2 FOR 3), OVERLAY(s PLACING 'x' FROM 2) FROM t SELECT OVERLAY('abc', 'x', 2) SELECT POSITION('b' IN s) FROM t SELECT TREAT(x AS text) FROM t SELECT TRIM(BOTH 'x' FROM s), TRIM(LEADING FROM s), TRIM(TRAILING 'y' FROM s), TRIM(s) FROM t SELECT NULLIF(a, b) FROM t CREATE TABLE tt OF ty CREATE TABLE tt OF ty (a WITH OPTIONS NOT NULL, PRIMARY KEY (a)) CREATE TABLE IF NOT EXISTS tt OF s.ty CREATE TABLE p2 PARTITION OF p (a NOT NULL) FOR VALUES FROM (1) TO (10) CREATE TABLE IF NOT EXISTS p3 PARTITION OF p (a WITH OPTIONS NOT NULL) FOR VALUES IN (1) CALL version(); CALL p(); CALL sch.p(1, 2 + 3); CALL p(a => 1, b => 'x'); CALL p(1, b := 2); CREATE TABLESPACE regress_ts LOCATION '/mnt/ts1' CREATE TABLESPACE regress_ts OWNER alice LOCATION '/mnt/ts1' WITH (random_page_cost = 2.0, seq_page_cost = 1.5) CREATE TABLESPACE regress_ts OWNER CURRENT_USER LOCATION '' DROP TABLESPACE regress_ts DROP TABLESPACE IF EXISTS regress_ts ALTER TABLESPACE regress_ts SET (random_page_cost = 4.0) ALTER TABLESPACE regress_ts RESET (random_page_cost, effective_io_concurrency) ALTER TABLESPACE regress_ts RENAME TO regress_ts2 ALTER TABLESPACE regress_ts OWNER TO bob GRANT CREATE ON TABLESPACE regress_ts TO alice REVOKE ALL ON TABLESPACE regress_ts FROM alice CREATE TABLE t (a int) TABLESPACE regress_ts CREATE INDEX ti ON t (a) TABLESPACE regress_ts CREATE TABLE tpk (a int, PRIMARY KEY (a) USING INDEX TABLESPACE regress_ts) ALTER TABLE t SET TABLESPACE regress_ts CREATE TABLESPACE CREATE TABLESPACE x DROP TABLESPACE CREATE TYPE widget CREATE TYPE s.myshell; CREATE TYPE widget (internallength = 24, input = widget_in, output = widget_out, typmod_in = numerictypmodin, typmod_out = numerictypmodout, alignment = double) CREATE TYPE city_budget (internallength = 16, input = int44in, output = int44out, element = int4, category = 'x', preferred = true) CREATE TYPE mytype (input = fn_in, output = fn_out, internallength = variable, alignment = int4, storage = extended, passedbyvalue, delimiter = ';', collatable = true, default = 'zippo', category = 'N', preferred = false, receive = myrecv, send = mysend, analyze = myanalyze, subscript = mysub, like = point, element = float4) CREATE TYPE t2 (internallength = VARIABLE, input = i, output = o, storage = plain) CREATE TYPE bogus (unknownattr = 4, input = a, output = b) CREATE TYPE s.q.t3 (input = qual.name0, output = qual.name2) CREATE TYPE CREATE TYPE t () PREPARE q AS SELECT 1 PREPARE q (int) AS SELECT $1 PREPARE q (int, text) AS SELECT $1 + 1, $2 PREPARE q AS INSERT INTO t VALUES ($1) PREPARE q AS UPDATE t SET a = $1 PREPARE q AS DELETE FROM t WHERE a = $1 EXECUTE q EXECUTE q (1) EXECUTE q (1 + 1, 'a' || 'b') CREATE TABLE t2 AS EXECUTE q CREATE TABLE t2 AS EXECUTE q (1, 'x') CREATE TABLE t2 AS EXECUTE q (1) WITH DATA CREATE TABLE t2 AS EXECUTE q (1) WITH NO DATA CREATE TEMP TABLE t2 AS EXECUTE q (1) CREATE TEMPORARY TABLE t2 (a, b) AS EXECUTE q (1, 'x') WITH NO DATA CREATE TABLE IF NOT EXISTS t2 AS EXECUTE q (1) CREATE TEMP TABLE IF NOT EXISTS t2 AS EXECUTE q (1) WITH NO DATA DEALLOCATE q DEALLOCATE PREPARE q DEALLOCATE ALL DEALLOCATE PREPARE ALL CREATE AGGREGATE avg2 (int4) (sfunc = int4pl, stype = int4, initcond = '0', parallel = safe) CREATE OR REPLACE AGGREGATE avg2 (x int4, y int8) (sfunc = int4pl, stype = int4, finalfunc = int8out, finalfunc_modify = read_only, mfinalfunc_extra) CREATE AGGREGATE cnt2 (*) (sfunc = int8inc, stype = int8) CREATE AGGREGATE rank2 (ORDER BY int4, boolean) (sfunc = ordered_set_transition_multi, stype = internal, finalfunc = rank_final, finalfunc_extra, hypothetical) CREATE AGGREGATE pctile2 (float8 ORDER BY float8) (sfunc = ordered_set_transition, stype = internal, finalfunc = percentile_disc_final, finalfunc_extra) CREATE AGGREGATE hypo2 (VARIADIC "any" ORDER BY VARIADIC "any") (sfunc = ordered_set_transition_multi, stype = internal, finalfunc = rank_final, hypothetical) CREATE AGGREGATE bad2 (VARIADIC "any" ORDER BY VARIADIC int4) (sfunc = ordered_set_transition_multi, stype = internal) CREATE AGGREGATE old2 (basetype = int4, sfunc = int4pl, stype = int4, initcond1 = '0') CREATE CAST (int4 AS bool) WITH FUNCTION bool(int4) CREATE CAST (int4 AS bool) WITH FUNCTION s.f(int4, int8) AS IMPLICIT CREATE CAST (bigint AS int4) WITH FUNCTION int4(bigint) AS ASSIGNMENT CREATE CAST (int4 AS money) WITHOUT FUNCTION CREATE CAST (int4 AS money) WITHOUT FUNCTION AS IMPLICIT CREATE CAST (int4 AS money) WITHOUT FUNCTION AS ASSIGNMENT CREATE CAST (text AS mytype) WITH INOUT CREATE CAST (text AS mytype) WITH INOUT AS IMPLICIT CREATE CAST (text AS mytype) WITH INOUT AS ASSIGNMENT CREATE TRANSFORM FOR int LANGUAGE plperl (FROM SQL WITH FUNCTION f1(internal), TO SQL WITH FUNCTION f2(internal)) CREATE OR REPLACE TRANSFORM FOR s.ty LANGUAGE plpython3u (TO SQL WITH FUNCTION f2(internal), FROM SQL WITH FUNCTION s.f1(internal, int4)) CREATE TRANSFORM FOR bool LANGUAGE plperl (FROM SQL WITH FUNCTION f1(internal)) CREATE TRANSFORM FOR bool LANGUAGE plperl (TO SQL WITH FUNCTION f2(internal)) CREATE ACCESS METHOD gist2 TYPE INDEX HANDLER gisthandler CREATE ACCESS METHOD heap2 TYPE TABLE HANDLER s.heap_handler CREATE TABLE IF NOT EXISTS t (a int, b text NOT NULL) CREATE TEMP TABLE IF NOT EXISTS s.t2 (a serial PRIMARY KEY) ON COMMIT DROP CREATE UNLOGGED TABLE IF NOT EXISTS t3 () WITH (fillfactor = 70) CREATE TABLE IF NOT EXISTS t4 (a int) INHERITS (p) USING heap TABLESPACE ts CREATE TABLE IF NOT EXISTS t5 (a int) PARTITION BY RANGE (a) GRANT SET ON PARAMETER work_mem TO pg_monitor GRANT SET, ALTER SYSTEM ON PARAMETER shared_buffers, hash_mem_multiplier TO pg_checkpoint WITH GRANT OPTION GRANT ALL ON PARAMETER plperl.on_init TO PUBLIC REVOKE ALL ON PARAMETER work_mem, plperl.on_init FROM pg_monitor CREATE CONVERSION myconv FOR 'LATIN1' TO 'UTF8' FROM myfunc; CREATE DEFAULT CONVERSION s.cnv2 FOR 'EUC_JP' TO 'MULE_INTERNAL' FROM s.f2; CREATE CONVERSION "Q C" FOR 'utf8' TO 'sjis' FROM cat.s.fn; DROP CONVERSION myconv; DROP CONVERSION IF EXISTS s.cnv2 CASCADE; CREATE LANGUAGE plsample; CREATE OR REPLACE TRUSTED LANGUAGE plsample; CREATE LANGUAGE plsample HANDLER plsample_call_handler; CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE plsample HANDLER s.h INLINE inl VALIDATOR s.v; CREATE LANGUAGE lang2 HANDLER h.a.b NO VALIDATOR; DROP LANGUAGE plsample; DROP PROCEDURAL LANGUAGE IF EXISTS plsample CASCADE VACUUM (PARALLEL 2) t; VACUUM (PARALLEL 0) t; VACUUM (PARALLEL 2, VERBOSE FALSE) t; VACUUM (opt1 1.5, opt2 -2, opt3 +3.5, opt4 -1.25) t; ANALYZE (opt5 7) t CREATE TYPE myrange AS RANGE (subtype = int4) CREATE TYPE s.floatrange AS RANGE (subtype = float8, subtype_diff = float8mi) CREATE TYPE textrange AS RANGE (subtype = text, collation = "C", subtype_opclass = text_ops) CREATE TYPE bigrange AS RANGE (subtype = int8, canonical = my_canonical, multirange_type_name = s.big_mr) CREATE TYPE norange AS RANGE CREATE TYPE badrange AS RANGE () ALTER COLLATION coll1 RENAME TO coll2; ALTER CONVERSION s.cnv RENAME TO cnv2; ALTER STATISTICS s.st1 RENAME TO st2; ALTER TYPE s.ty RENAME TO ty2; ALTER TEXT SEARCH PARSER prs RENAME TO prs2; ALTER TEXT SEARCH DICTIONARY s.dict RENAME TO d2; ALTER TEXT SEARCH TEMPLATE tmpl RENAME TO t2; ALTER TEXT SEARCH CONFIGURATION s.cfg RENAME TO c2 ALTER FOREIGN DATA WRAPPER fdw1 RENAME TO fdw2; ALTER LANGUAGE plsample RENAME TO plsample2; ALTER PROCEDURAL LANGUAGE l1 RENAME TO l2; ALTER SERVER srv RENAME TO srv2; ALTER EVENT TRIGGER evt RENAME TO evt2; ALTER OPERATOR CLASS s.oc USING btree RENAME TO oc2; ALTER OPERATOR FAMILY fam USING hash RENAME TO fam2 ALTER GROUP g1 RENAME TO g2; ALTER ROLE r1 RENAME TO r2; ALTER USER u1 RENAME TO u2; ALTER SCHEMA s1 RENAME TO s2 ALTER SEQUENCE seq1 RENAME TO seq2; ALTER SEQUENCE IF EXISTS s.seq RENAME TO seq3; ALTER VIEW v1 RENAME TO v2; ALTER VIEW IF EXISTS s.v RENAME TO v3; ALTER MATERIALIZED VIEW mv RENAME TO mv2; ALTER MATERIALIZED VIEW IF EXISTS s.mv RENAME TO mv3; ALTER INDEX i1 RENAME TO i2; ALTER INDEX IF EXISTS s.i RENAME TO i3; ALTER FOREIGN TABLE ft RENAME TO ft2; ALTER FOREIGN TABLE IF EXISTS s.ft RENAME TO ft3 ALTER VIEW v1 RENAME COLUMN c1 TO c2; ALTER VIEW IF EXISTS v1 RENAME c1 TO c2; ALTER MATERIALIZED VIEW mv RENAME COLUMN a TO b; ALTER MATERIALIZED VIEW IF EXISTS mv RENAME a TO b; ALTER FOREIGN TABLE ft RENAME COLUMN x TO y; ALTER FOREIGN TABLE IF EXISTS ft RENAME x TO y; ALTER RULE myrule ON t1 RENAME TO r2; ALTER TYPE s.ty RENAME ATTRIBUTE att TO att2 CASCADE; ALTER TYPE ty RENAME ATTRIBUTE a TO b ALTER AGGREGATE agg(int4) SET SCHEMA s2; ALTER COLLATION coll SET SCHEMA s2; ALTER CONVERSION cnv SET SCHEMA s2; ALTER EXTENSION ext SET SCHEMA s2; ALTER FUNCTION f(int4, text) SET SCHEMA s2; ALTER OPERATOR my.+ (int4, int4) SET SCHEMA s2; ALTER OPERATOR CLASS oc USING btree SET SCHEMA s2; ALTER OPERATOR FAMILY fam USING gist SET SCHEMA s2; ALTER PROCEDURE p(int4) SET SCHEMA s2; ALTER ROUTINE rt(int4) SET SCHEMA s2; ALTER STATISTICS st SET SCHEMA s2; ALTER TEXT SEARCH PARSER prs SET SCHEMA s2; ALTER TEXT SEARCH DICTIONARY dict SET SCHEMA s2; ALTER TEXT SEARCH TEMPLATE tmpl SET SCHEMA s2; ALTER TEXT SEARCH CONFIGURATION cfg SET SCHEMA s2; ALTER TYPE ty SET SCHEMA s2 ALTER TABLE t1 SET SCHEMA s2; ALTER TABLE IF EXISTS t1 SET SCHEMA s2; ALTER SEQUENCE sq SET SCHEMA s2; ALTER SEQUENCE IF EXISTS sq SET SCHEMA s2; ALTER VIEW v SET SCHEMA s2; ALTER VIEW IF EXISTS v SET SCHEMA s2; ALTER MATERIALIZED VIEW mv SET SCHEMA s2; ALTER MATERIALIZED VIEW IF EXISTS mv SET SCHEMA s2; ALTER FOREIGN TABLE ft SET SCHEMA s2; ALTER FOREIGN TABLE IF EXISTS ft SET SCHEMA s2 ALTER COLLATION coll OWNER TO rol; ALTER CONVERSION cnv OWNER TO rol; ALTER TYPE ty OWNER TO CURRENT_USER; ALTER STATISTICS st OWNER TO rol; ALTER LANGUAGE lang OWNER TO rol; ALTER PROCEDURAL LANGUAGE lang2 OWNER TO rol; ALTER SCHEMA s1 OWNER TO rol; ALTER FOREIGN DATA WRAPPER fdw OWNER TO rol; ALTER SERVER srv OWNER TO rol; ALTER EVENT TRIGGER evt OWNER TO rol; ALTER LARGE OBJECT 42 OWNER TO rol; ALTER OPERATOR my.@@ (int4, int8) OWNER TO rol; ALTER OPERATOR CLASS oc USING btree OWNER TO rol; ALTER OPERATOR FAMILY fam USING btree OWNER TO rol; ALTER TEXT SEARCH DICTIONARY dict OWNER TO rol; ALTER TEXT SEARCH CONFIGURATION cfg OWNER TO SESSION_USER CREATE STATISTICS s1 (ndistinct, dependencies) ON a, b FROM t; CREATE STATISTICS IF NOT EXISTS sch.s2 (mcv) ON (a+b), c FROM sch.t; CREATE STATISTICS ON a, b FROM t; CREATE STATISTICS s3 ON (lower(x)) FROM t; CREATE STATISTICS s4 ON a FROM t; CREATE STATISTICS s5 (ndistinct) ON a, upper(b) FROM ONLY t; ALTER STATISTICS s1 SET STATISTICS 100; ALTER STATISTICS IF EXISTS sch.s1 SET STATISTICS -1; ALTER STATISTICS s2 SET STATISTICS DEFAULT ALTER STATISTICS SET STATISTICS 5 ALTER STATISTICS s1 RENAME TO s2; ALTER STATISTICS sch.s1 RENAME TO s2 SELECT * FROM t TABLESAMPLE BERNOULLI (10); SELECT * FROM t TABLESAMPLE SYSTEM (50) REPEATABLE (0); SELECT a FROM t AS x TABLESAMPLE bernoulli (1.5) WHERE a > 0; SELECT * FROM ONLY t TABLESAMPLE system (0.1) REPEATABLE (1 + 2); SELECT * FROM s.t TABLESAMPLE foo.bar (1, 2) REPEATABLE (x); SELECT * FROM t x(a, b) TABLESAMPLE bernoulli (50), u JOIN v ON true; SELECT * FROM t TABLESAMPLE bernoulli (10) REPEATABLE (-1); SELECT * FROM t * TABLESAMPLE system ($1); ALTER TYPE s.ty ADD ATTRIBUTE a int RESTRICT ALTER TYPE ty ADD ATTRIBUTE b text CASCADE ALTER TYPE ty DROP ATTRIBUTE IF EXISTS a CASCADE ALTER TYPE ty DROP ATTRIBUTE a ALTER TYPE ty ALTER ATTRIBUTE a SET DATA TYPE numeric(10, 2) COLLATE "C" CASCADE ALTER TYPE cat.s.ty ALTER ATTRIBUTE a TYPE text, DROP ATTRIBUTE b, ADD ATTRIBUTE c int ALTER TYPE a.b.c.d ADD ATTRIBUTE x int ALTER ROLE r1 RENAME TO r2 ALTER FUNCTION f(int) SET search_path TO public, pg_temp ALTER FUNCTION f(int, text) RESET search_path RESTRICT ALTER PROCEDURE p(int) RESET ALL ALTER SCHEMA myschema OWNER TO newowner ALTER SCHEMA s2 OWNER TO CURRENT_USER SELECT (SELECT a FROM t).b SELECT (SELECT a FROM t).b[1] SELECT (SELECT a FROM t).c[1:2] SELECT ((SELECT a FROM t)).* SELECT (SELECT a FROM t).*.b UPDATE t SET (a, b) = (1, 2) UPDATE t SET (a, b) = (SELECT 1, 2) UPDATE s.t SET (a) = ROW(1) WHERE a = 0 UPDATE t SET (a, b.c) = (1, 2), x = 3 UPDATE t SET (a[1], b) = (SELECT x, y FROM u) SELECT * FROM JSON_TABLE('[]', '$' COLUMNS (a int)); SELECT * FROM JSON_TABLE(jsonb '[1,2,3]', '$[*]' AS rootpath COLUMNS (a int PATH '$')) jt; SELECT jt.* FROM JSON_TABLE(js, '$' COLUMNS (x text)) AS jt(y); SELECT * FROM t, LATERAL JSON_TABLE(t.j, '$[*]' COLUMNS (a int PATH '$.a')) jt; SELECT * FROM JSON_TABLE(doc FORMAT JSON, '$' COLUMNS (a int)) SELECT * FROM JSON_TABLE('[]', '$[*]' COLUMNS (id FOR ORDINALITY, a int PATH '$.a', b text, c jsonb FORMAT JSON PATH '$.c' WITH WRAPPER, d text FORMAT JSON OMIT QUOTES, e int EXISTS PATH '$.e', f int EXISTS, g text PATH '$.g' KEEP QUOTES ON SCALAR STRING)); SELECT * FROM JSON_TABLE('[]', '$' COLUMNS (a int PATH '$.a' DEFAULT 1 ON EMPTY DEFAULT 2 ON ERROR, b text PATH '$.b' NULL ON EMPTY ERROR ON ERROR, c jsonb PATH '$.c' EMPTY ARRAY ON ERROR, d jsonb PATH '$.d' EMPTY OBJECT ON EMPTY, e int EXISTS PATH '$.e' TRUE ON ERROR, f int EXISTS PATH '$.f' UNKNOWN ON ERROR)) SELECT * FROM JSON_TABLE('[]', '$[*]' AS p0 PASSING 1 AS x, '2' FORMAT JSON AS y COLUMNS (a int, NESTED PATH '$.b[*]' AS pb COLUMNS (b int), NESTED '$.c[*]' COLUMNS (c text PATH '$', NESTED PATH '$.d' AS pd COLUMNS (d int))) EMPTY ARRAY ON ERROR); SELECT * FROM JSON_TABLE('[]', '$' COLUMNS (a int) ERROR ON ERROR); SELECT * FROM JSON_TABLE('[]', '$' COLUMNS (a int) EMPTY ON ERROR); SELECT * FROM JSON_TABLE('[]', '$' COLUMNS (c1 json FORMAT JSON PATH '$' WITH CONDITIONAL ARRAY WRAPPER, c2 json PATH '$' WITHOUT WRAPPER, c3 json PATH '$' WITH UNCONDITIONAL WRAPPER)); SELECT * FROM JSON_TABLE(js, 1 COLUMNS (a int)); SELECT * FROM JSON_TABLE('[]', '$' COLUMNS (NESTED PATH '$.x' COLUMNS (a FOR ORDINALITY))) SELECT CAST(1 AS int ARRAY[4]); SELECT CAST(NULL AS text ARRAY); CREATE TABLE gramblk_arr (a int ARRAY[3], b text ARRAY, c int[2][3]) CREATE FUNCTION gramblk_f1() RETURNS SETOF int ARRAY[3] LANGUAGE sql AS 'SELECT 1'; CREATE FUNCTION gramblk_f2() RETURNS SETOF int ARRAY LANGUAGE sql AS 'SELECT 1' CREATE TABLE gramblk_ca (a int REFERENCES gramblk_arr (a) DEFERRABLE INITIALLY DEFERRED, b int REFERENCES gramblk_arr (a) NOT DEFERRABLE INITIALLY IMMEDIATE) CREATE TABLE gramblk_ca2 (a int CHECK (a > 0) ENFORCED, b int CHECK (b > 0) NOT ENFORCED) CREATE FUNCTION gramblk_f3(x int) RETURNS int LANGUAGE SQL RETURN x + 1 CREATE FUNCTION gramblk_f4() RETURNS int LANGUAGE SQL BEGIN ATOMIC SELECT 1; END CREATE PROCEDURE gramblk_p1() LANGUAGE SQL BEGIN ATOMIC END CREATE PROCEDURE gramblk_p2() LANGUAGE SQL BEGIN ATOMIC SELECT 1; SELECT 2; END CREATE SCHEMA AUTHORIZATION gramblk_role CREATE SCHEMA gramblk_s1 AUTHORIZATION gramblk_role CREATE TABLE t1 (a int) CREATE SCHEMA gramblk_s2 CREATE TABLE t2 (b int) CREATE VIEW v2 AS SELECT b FROM t2 CREATE INDEX i2 ON t2 (b) CREATE SEQUENCE sq2 GRANT SELECT ON t2 TO PUBLIC CREATE SCHEMA IF NOT EXISTS gramblk_s3 AUTHORIZATION gramblk_role; CREATE SCHEMA IF NOT EXISTS gramblk_s4 UPDATE gramblk_arr SET a = 1 RETURNING WITH (OLD AS o, NEW AS n) o.a, n.a DELETE FROM gramblk_arr WHERE a = 1 RETURNING WITH (OLD AS o) o.a; INSERT INTO gramblk_arr VALUES (1) RETURNING WITH (NEW AS n) n.a DROP CAST (int AS bigint); DROP CAST IF EXISTS (int AS bigint) CASCADE DROP TRANSFORM FOR int LANGUAGE plpgsql; DROP TRANSFORM IF EXISTS FOR int LANGUAGE plpgsql RESTRICT DROP INDEX CONCURRENTLY gramblk_i1; DROP INDEX CONCURRENTLY IF EXISTS gramblk_i1, gramblk_i2 CASCADE CREATE TABLE gramblk_t3 (id int, valid_at daterange, PRIMARY KEY (id, valid_at WITHOUT OVERLAPS)) CREATE TABLE gramblk_t4 (id int, valid_at daterange, UNIQUE (id, valid_at WITHOUT OVERLAPS)) ALTER TYPE mytype SET (RECEIVE = myrecv, SEND = mysend); ALTER TYPE sch.mytype SET (TYPMOD_IN = tmi, TYPMOD_OUT = tmo, ANALYZE = anlz, SUBSCRIPT = subs) ALTER TYPE mytype SET (STORAGE = extended); ALTER TYPE mytype SET (RECEIVE = NONE, SEND = NONE, ANALYZE = NONE); ALTER TYPE pg_catalog.mytype SET (TYPMOD_IN = NONE, TYPMOD_OUT = NONE, SUBSCRIPT = NONE) ALTER TYPE mytype SET (STORAGE = plain, storage = main) ALTER TYPE SET (STORAGE = plain) ALTER TYPE mytype SET () ALTER COLLATION c1 REFRESH VERSION; ALTER COLLATION sch.c2 REFRESH VERSION ALTER TABLE t1 ALTER CONSTRAINT c1 DEFERRABLE INITIALLY DEFERRED ALTER TABLE t1 ALTER CONSTRAINT c1 NOT DEFERRABLE ALTER TABLE ONLY t1 ALTER CONSTRAINT c1 DEFERRABLE INITIALLY IMMEDIATE ALTER TABLE t1 ALTER CONSTRAINT c1 ENFORCED ALTER TABLE t1 ALTER CONSTRAINT c1 NOT ENFORCED ALTER TABLE t1 ALTER CONSTRAINT c1 NOT ENFORCED NOT DEFERRABLE ALTER TABLE t1 ALTER CONSTRAINT c1 NO INHERIT ALTER TABLE t1 ALTER CONSTRAINT c1 NOT VALID ALTER TABLE t1 ALTER CONSTRAINT c1 INHERIT ALTER TABLE IF EXISTS sch.t2 ALTER CONSTRAINT c2 DEFERRABLE, VALIDATE CONSTRAINT c3 ALTER SEQUENCE seq1 SET LOGGED ALTER SEQUENCE IF EXISTS sch.seq2 SET UNLOGGED ALTER FOREIGN TABLE ft1 ADD COLUMN c4 integer ALTER FOREIGN TABLE IF EXISTS sch.ft2 DROP COLUMN c1 ALTER FOREIGN TABLE ft1 OPTIONS (ADD delimiter ',', SET quote '~', DROP escape) ALTER FOREIGN TABLE ft1 ALTER COLUMN c1 OPTIONS (ADD param1 'val1') ALTER FOREIGN TABLE ft1 ALTER COLUMN c2 SET NOT NULL GRANT USAGE ON FOREIGN DATA WRAPPER foo TO regress_test_role GRANT ALL ON FOREIGN DATA WRAPPER foo, bar TO PUBLIC WITH GRANT OPTION REVOKE USAGE ON FOREIGN SERVER s1 FROM regress_test_role CASCADE GRANT USAGE ON FOREIGN SERVER s1, s2 TO regress_test_role2 WITH GRANT OPTION CREATE TABLE wo_fk1 (id int4range, valid_at daterange, CONSTRAINT wo_fk1_fk FOREIGN KEY (id, PERIOD valid_at) REFERENCES wo_pk1 (id, PERIOD valid_at)) CREATE TABLE wo_fk2 (id int4range, valid_at daterange, CONSTRAINT wo_fk2_fk FOREIGN KEY (id, PERIOD valid_at) REFERENCES wo_pk1) ALTER TABLE wo_fk1 ADD CONSTRAINT wo_fk3_fk FOREIGN KEY (id, PERIOD valid_at) REFERENCES wo_pk1 (id, PERIOD valid_at) MATCH SIMPLE ON DELETE RESTRICT ON UPDATE RESTRICT ALTER TABLE wo_fk1 ADD CONSTRAINT wo_fk4_fk FOREIGN KEY (id) REFERENCES wo_pk1 (id, PERIOD valid_at) ALTER TABLE wo_fk1 ADD CONSTRAINT wo_fk5_fk FOREIGN KEY (id, PERIOD valid_at) REFERENCES wo_pk1 (id) DEFERRABLE INITIALLY DEFERRED SELECT merge_action() SELECT MERGE_ACTION(), merge_action ( ) AS act MERGE INTO tgt t USING src s ON t.id = s.id WHEN MATCHED THEN UPDATE SET val = s.val WHEN NOT MATCHED THEN INSERT (id, val) VALUES (s.id, s.val) RETURNING merge_action(), t.* MERGE INTO tgt USING src ON tgt.id = src.id WHEN MATCHED AND merge_action() = 'UPDATE' THEN DELETE RETURNING merge_action() AS act, old.id, new.id INSERT INTO t VALUES (1) RETURNING merge_action() MERGE INTO tgt USING src ON tgt.id = src.id WHEN NOT MATCHED THEN INSERT VALUES (src.id) RETURNING (SELECT merge_action()) CREATE RECURSIVE VIEW vr (n) AS SELECT 1 CREATE OR REPLACE TEMP RECURSIVE VIEW s.vr (a, b) AS SELECT 1, 2 CREATE RECURSIVE VIEW vr (n) AS SELECT 1 WITH CHECK OPTION DROP OPERATOR !!! (NONE, integer) DROP OPERATOR IF EXISTS s.@#@ (bigint, NONE) CASCADE COMMENT ON OPERATOR !!! (NONE, boolean) IS 'prefix' DROP OPERATOR !!! (integer) ALTER MATERIALIZED VIEW mv OWNER TO r ALTER MATERIALIZED VIEW IF EXISTS s.mv SET (fillfactor = 70), CLUSTER ON idx GRANT SELECT ON ALL TABLES IN SCHEMA s, s2 TO u REVOKE ALL ON ALL SEQUENCES IN SCHEMA s FROM u CASCADE ALTER TABLE ALL IN TABLESPACE ts SET TABLESPACE ts2 ALTER TABLE ALL IN TABLESPACE ts OWNED BY r1, r2 SET TABLESPACE ts2 NOWAIT ALTER INDEX ALL IN TABLESPACE ts SET TABLESPACE ts2 NOWAIT ALTER INDEX ALL IN TABLESPACE ts OWNED BY CURRENT_USER SET TABLESPACE ts2 ALTER MATERIALIZED VIEW ALL IN TABLESPACE ts SET TABLESPACE ts2 ALTER MATERIALIZED VIEW ALL IN TABLESPACE ts OWNED BY r SET TABLESPACE ts2 NOWAIT