summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/test/regress/expected/inherit_1.out1353
-rw-r--r--src/test/regress/sql/inherit.sql45
2 files changed, 1398 insertions, 0 deletions
diff --git a/src/test/regress/expected/inherit_1.out b/src/test/regress/expected/inherit_1.out
new file mode 100644
index 0000000000..5d4cf3230b
--- /dev/null
+++ b/src/test/regress/expected/inherit_1.out
@@ -0,0 +1,1353 @@
+--
+-- Test inheritance features
+--
+CREATE TABLE a (aa TEXT);
+CREATE TABLE b (bb TEXT) INHERITS (a);
+CREATE TABLE c (cc TEXT) INHERITS (a);
+CREATE TABLE d (dd TEXT) INHERITS (b,c,a);
+NOTICE: merging multiple inherited definitions of column "aa"
+NOTICE: merging multiple inherited definitions of column "aa"
+ERROR: Cannot currently distribute a table with more than one parent.
+INSERT INTO a(aa) VALUES('aaa');
+INSERT INTO a(aa) VALUES('aaaa');
+INSERT INTO a(aa) VALUES('aaaaa');
+INSERT INTO a(aa) VALUES('aaaaaa');
+INSERT INTO a(aa) VALUES('aaaaaaa');
+INSERT INTO a(aa) VALUES('aaaaaaaa');
+INSERT INTO b(aa) VALUES('bbb');
+INSERT INTO b(aa) VALUES('bbbb');
+INSERT INTO b(aa) VALUES('bbbbb');
+INSERT INTO b(aa) VALUES('bbbbbb');
+INSERT INTO b(aa) VALUES('bbbbbbb');
+INSERT INTO b(aa) VALUES('bbbbbbbb');
+INSERT INTO c(aa) VALUES('ccc');
+INSERT INTO c(aa) VALUES('cccc');
+INSERT INTO c(aa) VALUES('ccccc');
+INSERT INTO c(aa) VALUES('cccccc');
+INSERT INTO c(aa) VALUES('ccccccc');
+INSERT INTO c(aa) VALUES('cccccccc');
+INSERT INTO d(aa) VALUES('ddd');
+ERROR: relation "d" does not exist
+LINE 1: INSERT INTO d(aa) VALUES('ddd');
+ ^
+INSERT INTO d(aa) VALUES('dddd');
+ERROR: relation "d" does not exist
+LINE 1: INSERT INTO d(aa) VALUES('dddd');
+ ^
+INSERT INTO d(aa) VALUES('ddddd');
+ERROR: relation "d" does not exist
+LINE 1: INSERT INTO d(aa) VALUES('ddddd');
+ ^
+INSERT INTO d(aa) VALUES('dddddd');
+ERROR: relation "d" does not exist
+LINE 1: INSERT INTO d(aa) VALUES('dddddd');
+ ^
+INSERT INTO d(aa) VALUES('ddddddd');
+ERROR: relation "d" does not exist
+LINE 1: INSERT INTO d(aa) VALUES('ddddddd');
+ ^
+INSERT INTO d(aa) VALUES('dddddddd');
+ERROR: relation "d" does not exist
+LINE 1: INSERT INTO d(aa) VALUES('dddddddd');
+ ^
+SELECT relname, a.* FROM a, pg_class where a.tableoid = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----
+(0 rows)
+
+SELECT relname, b.* FROM b, pg_class where b.tableoid = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----+----
+(0 rows)
+
+SELECT relname, c.* FROM c, pg_class where c.tableoid = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----+----
+(0 rows)
+
+SELECT relname, d.* FROM d, pg_class where d.tableoid = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM d, pg_class where d.tableoid = pg_c...
+ ^
+SELECT relname, a.* FROM ONLY a, pg_class where a.tableoid = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----
+(0 rows)
+
+SELECT relname, b.* FROM ONLY b, pg_class where b.tableoid = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----+----
+(0 rows)
+
+SELECT relname, c.* FROM ONLY c, pg_class where c.tableoid = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----+----
+(0 rows)
+
+SELECT relname, d.* FROM ONLY d, pg_class where d.tableoid = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM ONLY d, pg_class where d.tableoid =...
+ ^
+-- In Postgres-XC, Oids are not consistent among nodes, but a cast on relation can be used for global operations on Oid
+SELECT relname, a.* FROM a, pg_class WHERE 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----------
+ a | aaa
+ a | aaaa
+ a | aaaaa
+ a | aaaaaa
+ a | aaaaaaa
+ a | aaaaaaaa
+ a | bbb
+ a | bbbb
+ a | bbbbb
+ a | bbbbbb
+ a | bbbbbbb
+ a | bbbbbbbb
+ a | ccc
+ a | cccc
+ a | ccccc
+ a | cccccc
+ a | ccccccc
+ a | cccccccc
+(18 rows)
+
+SELECT relname, b.* FROM b, pg_class WHERE 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----------+----
+ b | bbb |
+ b | bbbb |
+ b | bbbbb |
+ b | bbbbbb |
+ b | bbbbbbb |
+ b | bbbbbbbb |
+(6 rows)
+
+SELECT relname, c.* FROM c, pg_class WHERE 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----------+----
+ c | ccc |
+ c | cccc |
+ c | ccccc |
+ c | cccccc |
+ c | ccccccc |
+ c | cccccccc |
+(6 rows)
+
+SELECT relname, d.* FROM d, pg_class WHERE 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM d, pg_class WHERE 'd'::regclass = p...
+ ^
+SELECT relname, a.* FROM ONLY a, pg_class where 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----------
+ a | aaa
+ a | aaaa
+ a | aaaaa
+ a | aaaaaa
+ a | aaaaaaa
+ a | aaaaaaaa
+(6 rows)
+
+SELECT relname, b.* FROM ONLY b, pg_class where 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----------+----
+ b | bbb |
+ b | bbbb |
+ b | bbbbb |
+ b | bbbbbb |
+ b | bbbbbbb |
+ b | bbbbbbbb |
+(6 rows)
+
+SELECT relname, c.* FROM ONLY c, pg_class where 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----------+----
+ c | ccc |
+ c | cccc |
+ c | ccccc |
+ c | cccccc |
+ c | ccccccc |
+ c | cccccccc |
+(6 rows)
+
+SELECT relname, d.* FROM ONLY d, pg_class where 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM ONLY d, pg_class where 'd'::regclas...
+ ^
+UPDATE a SET aa='zzzz' WHERE aa='aaaa';
+ERROR: Partition column can't be updated in current version
+UPDATE ONLY a SET aa='zzzzz' WHERE aa='aaaaa';
+ERROR: Partition column can't be updated in current version
+UPDATE b SET aa='zzz' WHERE aa='aaa';
+ERROR: Partition column can't be updated in current version
+UPDATE ONLY b SET aa='zzz' WHERE aa='aaa';
+ERROR: Partition column can't be updated in current version
+UPDATE a SET aa='zzzzzz' WHERE aa LIKE 'aaa%';
+ERROR: Partition column can't be updated in current version
+SELECT relname, a.* FROM a, pg_class where a.tableoid = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----
+(0 rows)
+
+SELECT relname, b.* FROM b, pg_class where b.tableoid = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----+----
+(0 rows)
+
+SELECT relname, c.* FROM c, pg_class where c.tableoid = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----+----
+(0 rows)
+
+SELECT relname, d.* FROM d, pg_class where d.tableoid = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM d, pg_class where d.tableoid = pg_c...
+ ^
+SELECT relname, a.* FROM ONLY a, pg_class where a.tableoid = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----
+(0 rows)
+
+SELECT relname, b.* FROM ONLY b, pg_class where b.tableoid = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----+----
+(0 rows)
+
+SELECT relname, c.* FROM ONLY c, pg_class where c.tableoid = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----+----
+(0 rows)
+
+SELECT relname, d.* FROM ONLY d, pg_class where d.tableoid = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM ONLY d, pg_class where d.tableoid =...
+ ^
+-- In Postgres-XC, Oids are not consistent among nodes, but a cast on relation can be used for global operations on Oid
+SELECT relname, a.* FROM a, pg_class WHERE 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----------
+ a | aaa
+ a | aaaa
+ a | aaaaa
+ a | aaaaaa
+ a | aaaaaaa
+ a | aaaaaaaa
+ a | bbb
+ a | bbbb
+ a | bbbbb
+ a | bbbbbb
+ a | bbbbbbb
+ a | bbbbbbbb
+ a | ccc
+ a | cccc
+ a | ccccc
+ a | cccccc
+ a | ccccccc
+ a | cccccccc
+(18 rows)
+
+SELECT relname, b.* FROM b, pg_class WHERE 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----------+----
+ b | bbb |
+ b | bbbb |
+ b | bbbbb |
+ b | bbbbbb |
+ b | bbbbbbb |
+ b | bbbbbbbb |
+(6 rows)
+
+SELECT relname, c.* FROM c, pg_class WHERE 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----------+----
+ c | ccc |
+ c | cccc |
+ c | ccccc |
+ c | cccccc |
+ c | ccccccc |
+ c | cccccccc |
+(6 rows)
+
+SELECT relname, d.* FROM d, pg_class WHERE 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM d, pg_class WHERE 'd'::regclass = p...
+ ^
+SELECT relname, a.* FROM ONLY a, pg_class where 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----------
+ a | aaa
+ a | aaaa
+ a | aaaaa
+ a | aaaaaa
+ a | aaaaaaa
+ a | aaaaaaaa
+(6 rows)
+
+SELECT relname, b.* FROM ONLY b, pg_class where 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----------+----
+ b | bbb |
+ b | bbbb |
+ b | bbbbb |
+ b | bbbbbb |
+ b | bbbbbbb |
+ b | bbbbbbbb |
+(6 rows)
+
+SELECT relname, c.* FROM ONLY c, pg_class where 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----------+----
+ c | ccc |
+ c | cccc |
+ c | ccccc |
+ c | cccccc |
+ c | ccccccc |
+ c | cccccccc |
+(6 rows)
+
+SELECT relname, d.* FROM ONLY d, pg_class where 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM ONLY d, pg_class where 'd'::regclas...
+ ^
+UPDATE b SET aa='new';
+ERROR: Partition column can't be updated in current version
+SELECT relname, a.* FROM a, pg_class where a.tableoid = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----
+(0 rows)
+
+SELECT relname, b.* FROM b, pg_class where b.tableoid = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----+----
+(0 rows)
+
+SELECT relname, c.* FROM c, pg_class where c.tableoid = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----+----
+(0 rows)
+
+SELECT relname, d.* FROM d, pg_class where d.tableoid = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM d, pg_class where d.tableoid = pg_c...
+ ^
+SELECT relname, a.* FROM ONLY a, pg_class where a.tableoid = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----
+(0 rows)
+
+SELECT relname, b.* FROM ONLY b, pg_class where b.tableoid = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----+----
+(0 rows)
+
+SELECT relname, c.* FROM ONLY c, pg_class where c.tableoid = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----+----
+(0 rows)
+
+SELECT relname, d.* FROM ONLY d, pg_class where d.tableoid = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM ONLY d, pg_class where d.tableoid =...
+ ^
+-- In Postgres-XC, Oids are not consistent among nodes, but a cast on relation can be used for global operations on Oid
+SELECT relname, a.* FROM a, pg_class WHERE 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----------
+ a | aaa
+ a | aaaa
+ a | aaaaa
+ a | aaaaaa
+ a | aaaaaaa
+ a | aaaaaaaa
+ a | bbb
+ a | bbbb
+ a | bbbbb
+ a | bbbbbb
+ a | bbbbbbb
+ a | bbbbbbbb
+ a | ccc
+ a | cccc
+ a | ccccc
+ a | cccccc
+ a | ccccccc
+ a | cccccccc
+(18 rows)
+
+SELECT relname, b.* FROM b, pg_class WHERE 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----------+----
+ b | bbb |
+ b | bbbb |
+ b | bbbbb |
+ b | bbbbbb |
+ b | bbbbbbb |
+ b | bbbbbbbb |
+(6 rows)
+
+SELECT relname, c.* FROM c, pg_class WHERE 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----------+----
+ c | ccc |
+ c | cccc |
+ c | ccccc |
+ c | cccccc |
+ c | ccccccc |
+ c | cccccccc |
+(6 rows)
+
+SELECT relname, d.* FROM d, pg_class WHERE 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM d, pg_class WHERE 'd'::regclass = p...
+ ^
+SELECT relname, a.* FROM ONLY a, pg_class where 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----------
+ a | aaa
+ a | aaaa
+ a | aaaaa
+ a | aaaaaa
+ a | aaaaaaa
+ a | aaaaaaaa
+(6 rows)
+
+SELECT relname, b.* FROM ONLY b, pg_class where 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----------+----
+ b | bbb |
+ b | bbbb |
+ b | bbbbb |
+ b | bbbbbb |
+ b | bbbbbbb |
+ b | bbbbbbbb |
+(6 rows)
+
+SELECT relname, c.* FROM ONLY c, pg_class where 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----------+----
+ c | ccc |
+ c | cccc |
+ c | ccccc |
+ c | cccccc |
+ c | ccccccc |
+ c | cccccccc |
+(6 rows)
+
+SELECT relname, d.* FROM ONLY d, pg_class where 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM ONLY d, pg_class where 'd'::regclas...
+ ^
+UPDATE a SET aa='new';
+ERROR: Partition column can't be updated in current version
+DELETE FROM ONLY c WHERE aa='new';
+SELECT relname, a.* FROM a, pg_class where a.tableoid = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----
+(0 rows)
+
+SELECT relname, b.* FROM b, pg_class where b.tableoid = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----+----
+(0 rows)
+
+SELECT relname, c.* FROM c, pg_class where c.tableoid = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----+----
+(0 rows)
+
+SELECT relname, d.* FROM d, pg_class where d.tableoid = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM d, pg_class where d.tableoid = pg_c...
+ ^
+SELECT relname, a.* FROM ONLY a, pg_class where a.tableoid = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----
+(0 rows)
+
+SELECT relname, b.* FROM ONLY b, pg_class where b.tableoid = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----+----
+(0 rows)
+
+SELECT relname, c.* FROM ONLY c, pg_class where c.tableoid = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----+----
+(0 rows)
+
+SELECT relname, d.* FROM ONLY d, pg_class where d.tableoid = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM ONLY d, pg_class where d.tableoid =...
+ ^
+-- In Postgres-XC, Oids are not consistent among nodes, but a cast on relation can be used for global operations on Oid
+SELECT relname, a.* FROM a, pg_class WHERE 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----------
+ a | aaa
+ a | aaaa
+ a | aaaaa
+ a | aaaaaa
+ a | aaaaaaa
+ a | aaaaaaaa
+ a | bbb
+ a | bbbb
+ a | bbbbb
+ a | bbbbbb
+ a | bbbbbbb
+ a | bbbbbbbb
+ a | ccc
+ a | cccc
+ a | ccccc
+ a | cccccc
+ a | ccccccc
+ a | cccccccc
+(18 rows)
+
+SELECT relname, b.* FROM b, pg_class WHERE 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----------+----
+ b | bbb |
+ b | bbbb |
+ b | bbbbb |
+ b | bbbbbb |
+ b | bbbbbbb |
+ b | bbbbbbbb |
+(6 rows)
+
+SELECT relname, c.* FROM c, pg_class WHERE 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----------+----
+ c | ccc |
+ c | cccc |
+ c | ccccc |
+ c | cccccc |
+ c | ccccccc |
+ c | cccccccc |
+(6 rows)
+
+SELECT relname, d.* FROM d, pg_class WHERE 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM d, pg_class WHERE 'd'::regclass = p...
+ ^
+SELECT relname, a.* FROM ONLY a, pg_class where 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----------
+ a | aaa
+ a | aaaa
+ a | aaaaa
+ a | aaaaaa
+ a | aaaaaaa
+ a | aaaaaaaa
+(6 rows)
+
+SELECT relname, b.* FROM ONLY b, pg_class where 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----------+----
+ b | bbb |
+ b | bbbb |
+ b | bbbbb |
+ b | bbbbbb |
+ b | bbbbbbb |
+ b | bbbbbbbb |
+(6 rows)
+
+SELECT relname, c.* FROM ONLY c, pg_class where 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----------+----
+ c | ccc |
+ c | cccc |
+ c | ccccc |
+ c | cccccc |
+ c | ccccccc |
+ c | cccccccc |
+(6 rows)
+
+SELECT relname, d.* FROM ONLY d, pg_class where 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM ONLY d, pg_class where 'd'::regclas...
+ ^
+DELETE FROM a;
+SELECT relname, a.* FROM a, pg_class where a.tableoid = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----
+(0 rows)
+
+SELECT relname, b.* FROM b, pg_class where b.tableoid = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----+----
+(0 rows)
+
+SELECT relname, c.* FROM c, pg_class where c.tableoid = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----+----
+(0 rows)
+
+SELECT relname, d.* FROM d, pg_class where d.tableoid = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM d, pg_class where d.tableoid = pg_c...
+ ^
+SELECT relname, a.* FROM ONLY a, pg_class where a.tableoid = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----
+(0 rows)
+
+SELECT relname, b.* FROM ONLY b, pg_class where b.tableoid = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----+----
+(0 rows)
+
+SELECT relname, c.* FROM ONLY c, pg_class where c.tableoid = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----+----
+(0 rows)
+
+SELECT relname, d.* FROM ONLY d, pg_class where d.tableoid = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM ONLY d, pg_class where d.tableoid =...
+ ^
+-- In Postgres-XC, Oids are not consistent among nodes, but a cast on relation can be used for global operations on Oid
+SELECT relname, a.* FROM a, pg_class WHERE 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----
+(0 rows)
+
+SELECT relname, b.* FROM b, pg_class WHERE 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----+----
+(0 rows)
+
+SELECT relname, c.* FROM c, pg_class WHERE 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----+----
+(0 rows)
+
+SELECT relname, d.* FROM d, pg_class WHERE 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM d, pg_class WHERE 'd'::regclass = p...
+ ^
+SELECT relname, a.* FROM ONLY a, pg_class where 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+ relname | aa
+---------+----
+(0 rows)
+
+SELECT relname, b.* FROM ONLY b, pg_class where 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+ relname | aa | bb
+---------+----+----
+(0 rows)
+
+SELECT relname, c.* FROM ONLY c, pg_class where 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+ relname | aa | cc
+---------+----+----
+(0 rows)
+
+SELECT relname, d.* FROM ONLY d, pg_class where 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
+ERROR: relation "d" does not exist
+LINE 1: SELECT relname, d.* FROM ONLY d, pg_class where 'd'::regclas...
+ ^
+-- Confirm PRIMARY KEY adds NOT NULL constraint to child table
+CREATE TEMP TABLE z (b TEXT, PRIMARY KEY(aa, b)) inherits (a);
+NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "z_pkey" for table "z"
+INSERT INTO z VALUES (NULL, 'text'); -- should fail
+ERROR: null value in column "aa" violates not-null constraint
+-- Check UPDATE with inherited target and an inherited source table
+create temp table foo(f1 int, f2 int);
+create temp table foo2(f3 int) inherits (foo);
+create temp table bar(f1 int, f2 int);
+create temp table bar2(f3 int) inherits (bar);
+insert into foo values(1,1);
+insert into foo values(3,3);
+insert into foo2 values(2,2,2);
+insert into foo2 values(3,3,3);
+insert into bar values(1,1);
+insert into bar values(2,2);
+insert into bar values(3,3);
+insert into bar values(4,4);
+insert into bar2 values(1,1,1);
+insert into bar2 values(2,2,2);
+insert into bar2 values(3,3,3);
+insert into bar2 values(4,4,4);
+update bar set f2 = f2 + 100 where f1 in (select f1 from foo);
+SELECT relname, bar.* FROM bar, pg_class where bar.tableoid = pg_class.oid
+order by 1,2;
+ relname | f1 | f2
+---------+----+-----
+ bar | 1 | 101
+ bar | 2 | 102
+ bar | 3 | 103
+ bar | 4 | 4
+ bar2 | 1 | 101
+ bar2 | 2 | 102
+ bar2 | 3 | 103
+ bar2 | 4 | 4
+(8 rows)
+
+/* Test multiple inheritance of column defaults */
+CREATE TABLE firstparent (tomorrow date default now()::date + 1);
+CREATE TABLE secondparent (tomorrow date default now() :: date + 1);
+CREATE TABLE jointchild () INHERITS (firstparent, secondparent); -- ok
+NOTICE: merging multiple inherited definitions of column "tomorrow"
+CREATE TABLE thirdparent (tomorrow date default now()::date - 1);
+CREATE TABLE otherchild () INHERITS (firstparent, thirdparent); -- not ok
+NOTICE: merging multiple inherited definitions of column "tomorrow"
+ERROR: column "tomorrow" inherits conflicting default values
+HINT: To resolve the conflict, specify a default explicitly.
+CREATE TABLE otherchild (tomorrow date default now())
+ INHERITS (firstparent, thirdparent); -- ok, child resolves ambiguous default
+NOTICE: merging multiple inherited definitions of column "tomorrow"
+NOTICE: merging column "tomorrow" with inherited definition
+DROP TABLE firstparent, secondparent, jointchild, thirdparent, otherchild;
+/* Test inheritance of structure (LIKE) */
+CREATE TABLE inhx (xx text DEFAULT 'text');
+/*
+ * Test double inheritance
+ *
+ * Ensure that defaults are NOT included unless
+ * INCLUDING DEFAULTS is specified
+ */
+CREATE TABLE inhe (ee text, LIKE inhx) inherits (b);
+INSERT INTO inhe VALUES ('ee-col1', 'ee-col2', DEFAULT, 'ee-col4');
+SELECT * FROM inhe; /* Columns aa, bb, xx value NULL, ee */
+ aa | bb | ee | xx
+---------+---------+----+---------
+ ee-col1 | ee-col2 | | ee-col4
+(1 row)
+
+SELECT * FROM inhx; /* Empty set since LIKE inherits structure only */
+ xx
+----
+(0 rows)
+
+SELECT * FROM b; /* Has ee entry */
+ aa | bb
+---------+---------
+ ee-col1 | ee-col2
+(1 row)
+
+SELECT * FROM a; /* Has ee entry */
+ aa
+---------
+ ee-col1
+(1 row)
+
+CREATE TABLE inhf (LIKE inhx, LIKE inhx); /* Throw error */
+ERROR: column "xx" specified more than once
+CREATE TABLE inhf (LIKE inhx INCLUDING DEFAULTS INCLUDING CONSTRAINTS);
+INSERT INTO inhf DEFAULT VALUES;
+SELECT * FROM inhf; /* Single entry with value 'text' */
+ xx
+------
+ text
+(1 row)
+
+ALTER TABLE inhx add constraint foo CHECK (xx = 'text');
+ALTER TABLE inhx ADD PRIMARY KEY (xx);
+NOTICE: ALTER TABLE / ADD PRIMARY KEY will create implicit index "inhx_pkey" for table "inhx"
+CREATE TABLE inhg (LIKE inhx); /* Doesn't copy constraint */
+INSERT INTO inhg VALUES ('foo');
+DROP TABLE inhg;
+CREATE TABLE inhg (x text, LIKE inhx INCLUDING CONSTRAINTS, y text); /* Copies constraints */
+INSERT INTO inhg VALUES ('x', 'text', 'y'); /* Succeeds */
+INSERT INTO inhg VALUES ('x', 'text', 'y'); /* Succeeds -- Unique constraints not copied */
+INSERT INTO inhg VALUES ('x', 'foo', 'y'); /* fails due to constraint */
+ERROR: new row for relation "inhg" violates check constraint "foo"
+SELECT * FROM inhg ORDER BY 1,2,3; /* Two records with three columns in order x=x, xx=text, y=y */
+ x | xx | y
+---+------+---
+ x | text | y
+ x | text | y
+(2 rows)
+
+DROP TABLE inhg;
+CREATE TABLE inhg (x text, LIKE inhx INCLUDING INDEXES, y text); /* copies indexes */
+NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "inhg_pkey" for table "inhg"
+INSERT INTO inhg VALUES (5, 10);
+INSERT INTO inhg VALUES (20, 10); -- should fail
+ERROR: duplicate key value violates unique constraint "inhg_pkey"
+DETAIL: Key (xx)=(10) already exists.
+DROP TABLE inhg;
+/* Multiple primary keys creation should fail */
+CREATE TABLE inhg (x text, LIKE inhx INCLUDING INDEXES, PRIMARY KEY(x)); /* fails */
+ERROR: multiple primary keys for table "inhg" are not allowed
+CREATE TABLE inhz (xx text DEFAULT 'text', yy int UNIQUE);
+NOTICE: CREATE TABLE / UNIQUE will create implicit index "inhz_yy_key" for table "inhz"
+CREATE UNIQUE INDEX inhz_xx_idx on inhz (xx) WHERE xx <> 'test';
+/* Ok to create multiple unique indexes */
+CREATE TABLE inhg (x text UNIQUE, LIKE inhz INCLUDING INDEXES);
+NOTICE: CREATE TABLE / UNIQUE will create implicit index "inhg_x_key" for table "inhg"
+NOTICE: CREATE TABLE / UNIQUE will create implicit index "inhg_yy_key" for table "inhg"
+INSERT INTO inhg (xx, yy, x) VALUES ('test', 5, 10);
+INSERT INTO inhg (xx, yy, x) VALUES ('test', 10, 15);
+INSERT INTO inhg (xx, yy, x) VALUES ('foo', 10, 15); -- should fail
+ERROR: duplicate key value violates unique constraint "inhg_x_key"
+DETAIL: Key (x)=(15) already exists.
+DROP TABLE inhg;
+DROP TABLE inhz;
+-- Test changing the type of inherited columns
+insert into d values('test','one','two','three');
+alter table a alter column aa type integer using bit_length(aa);
+select * from d;
+ aa | bb | cc | dd
+----+-----+-----+-------
+ 32 | one | two | three
+(1 row)
+
+-- Tests for casting between the rowtypes of parent and child
+-- tables. See the pgsql-hackers thread beginning Dec. 4/04
+create table base (i integer);
+create table derived () inherits (base);
+insert into derived (i) values (0);
+select derived::base from derived;
+ derived
+---------
+ (0)
+(1 row)
+
+drop table derived;
+drop table base;
+create table p1(ff1 int);
+create table p2(f1 text);
+create function p2text(p2) returns text as 'select $1.f1' language sql;
+create table c1(f3 int) inherits(p1,p2);
+insert into c1 values(123456789, 'hi', 42);
+select p2text(c1.*) from c1;
+ p2text
+--------
+ hi
+(1 row)
+
+drop function p2text(p2);
+drop table c1;
+drop table p2;
+drop table p1;
+CREATE TABLE ac (aa TEXT);
+alter table ac add constraint ac_check check (aa is not null);
+CREATE TABLE bc (bb TEXT) INHERITS (ac);
+select pc.relname, pgc.conname, pgc.contype, pgc.conislocal, pgc.coninhcount, pgc.consrc from pg_class as pc inner join pg_constraint as pgc on (pgc.conrelid = pc.oid) where pc.relname in ('ac', 'bc') order by 1,2;
+ relname | conname | contype | conislocal | coninhcount | consrc
+---------+----------+---------+------------+-------------+------------------
+ ac | ac_check | c | t | 0 | (aa IS NOT NULL)
+ bc | ac_check | c | f | 1 | (aa IS NOT NULL)
+(2 rows)
+
+insert into ac (aa) values (NULL);
+ERROR: new row for relation "ac" violates check constraint "ac_check"
+insert into bc (aa) values (NULL);
+ERROR: new row for relation "bc" violates check constraint "ac_check"
+alter table bc drop constraint ac_check; -- fail, disallowed
+ERROR: cannot drop inherited constraint "ac_check" of relation "bc"
+alter table ac drop constraint ac_check;
+select pc.relname, pgc.conname, pgc.contype, pgc.conislocal, pgc.coninhcount, pgc.consrc from pg_class as pc inner join pg_constraint as pgc on (pgc.conrelid = pc.oid) where pc.relname in ('ac', 'bc') order by 1,2;
+ relname | conname | contype | conislocal | coninhcount | consrc
+---------+---------+---------+------------+-------------+--------
+(0 rows)
+
+-- try the unnamed-constraint case
+alter table ac add check (aa is not null);
+select pc.relname, pgc.conname, pgc.contype, pgc.conislocal, pgc.coninhcount, pgc.consrc from pg_class as pc inner join pg_constraint as pgc on (pgc.conrelid = pc.oid) where pc.relname in ('ac', 'bc') order by 1,2;
+ relname | conname | contype | conislocal | coninhcount | consrc
+---------+-------------+---------+------------+-------------+------------------
+ ac | ac_aa_check | c | t | 0 | (aa IS NOT NULL)
+ bc | ac_aa_check | c | f | 1 | (aa IS NOT NULL)
+(2 rows)
+
+insert into ac (aa) values (NULL);
+ERROR: new row for relation "ac" violates check constraint "ac_aa_check"
+insert into bc (aa) values (NULL);
+ERROR: new row for relation "bc" violates check constraint "ac_aa_check"
+alter table bc drop constraint ac_aa_check; -- fail, disallowed
+ERROR: cannot drop inherited constraint "ac_aa_check" of relation "bc"
+alter table ac drop constraint ac_aa_check;
+select pc.relname, pgc.conname, pgc.contype, pgc.conislocal, pgc.coninhcount, pgc.consrc from pg_class as pc inner join pg_constraint as pgc on (pgc.conrelid = pc.oid) where pc.relname in ('ac', 'bc') order by 1,2;
+ relname | conname | contype | conislocal | coninhcount | consrc
+---------+---------+---------+------------+-------------+--------
+(0 rows)
+
+alter table ac add constraint ac_check check (aa is not null);
+alter table bc no inherit ac;
+select pc.relname, pgc.conname, pgc.contype, pgc.conislocal, pgc.coninhcount, pgc.consrc from pg_class as pc inner join pg_constraint as pgc on (pgc.conrelid = pc.oid) where pc.relname in ('ac', 'bc') order by 1,2;
+ relname | conname | contype | conislocal | coninhcount | consrc
+---------+----------+---------+------------+-------------+------------------
+ ac | ac_check | c | t | 0 | (aa IS NOT NULL)
+ bc | ac_check | c | t | 0 | (aa IS NOT NULL)
+(2 rows)
+
+alter table bc drop constraint ac_check;
+select pc.relname, pgc.conname, pgc.contype, pgc.conislocal, pgc.coninhcount, pgc.consrc from pg_class as pc inner join pg_constraint as pgc on (pgc.conrelid = pc.oid) where pc.relname in ('ac', 'bc') order by 1,2;
+ relname | conname | contype | conislocal | coninhcount | consrc
+---------+----------+---------+------------+-------------+------------------
+ ac | ac_check | c | t | 0 | (aa IS NOT NULL)
+(1 row)
+
+alter table ac drop constraint ac_check;
+select pc.relname, pgc.conname, pgc.contype, pgc.conislocal, pgc.coninhcount, pgc.consrc from pg_class as pc inner join pg_constraint as pgc on (pgc.conrelid = pc.oid) where pc.relname in ('ac', 'bc') order by 1,2;
+ relname | conname | contype | conislocal | coninhcount | consrc
+---------+---------+---------+------------+-------------+--------
+(0 rows)
+
+drop table bc;
+drop table ac;
+create table ac (a int constraint check_a check (a <> 0));
+create table bc (a int constraint check_a check (a <> 0), b int constraint check_b check (b <> 0)) inherits (ac);
+NOTICE: merging column "a" with inherited definition
+NOTICE: merging constraint "check_a" with inherited definition
+select pc.relname, pgc.conname, pgc.contype, pgc.conislocal, pgc.coninhcount, pgc.consrc from pg_class as pc inner join pg_constraint as pgc on (pgc.conrelid = pc.oid) where pc.relname in ('ac', 'bc') order by 1,2;
+ relname | conname | contype | conislocal | coninhcount | consrc
+---------+---------+---------+------------+-------------+----------
+ ac | check_a | c | t | 0 | (a <> 0)
+ bc | check_a | c | t | 1 | (a <> 0)
+ bc | check_b | c | t | 0 | (b <> 0)
+(3 rows)
+
+drop table bc;
+drop table ac;
+create table ac (a int constraint check_a check (a <> 0));
+create table bc (b int constraint check_b check (b <> 0));
+create table cc (c int constraint check_c check (c <> 0)) inherits (ac, bc);
+select pc.relname, pgc.conname, pgc.contype, pgc.conislocal, pgc.coninhcount, pgc.consrc from pg_class as pc inner join pg_constraint as pgc on (pgc.conrelid = pc.oid) where pc.relname in ('ac', 'bc', 'cc') order by 1,2;
+ relname | conname | contype | conislocal | coninhcount | consrc
+---------+---------+---------+------------+-------------+----------
+ ac | check_a | c | t | 0 | (a <> 0)
+ bc | check_b | c | t | 0 | (b <> 0)
+ cc | check_a | c | f | 1 | (a <> 0)
+ cc | check_b | c | f | 1 | (b <> 0)
+ cc | check_c | c | t | 0 | (c <> 0)
+(5 rows)
+
+alter table cc no inherit bc;
+select pc.relname, pgc.conname, pgc.contype, pgc.conislocal, pgc.coninhcount, pgc.consrc from pg_class as pc inner join pg_constraint as pgc on (pgc.conrelid = pc.oid) where pc.relname in ('ac', 'bc', 'cc') order by 1,2;
+ relname | conname | contype | conislocal | coninhcount | consrc
+---------+---------+---------+------------+-------------+----------
+ ac | check_a | c | t | 0 | (a <> 0)
+ bc | check_b | c | t | 0 | (b <> 0)
+ cc | check_a | c | f | 1 | (a <> 0)
+ cc | check_b | c | t | 0 | (b <> 0)
+ cc | check_c | c | t | 0 | (c <> 0)
+(5 rows)
+
+drop table cc;
+drop table bc;
+drop table ac;
+create table p1(f1 int);
+create table p2(f2 int);
+create table c1(f3 int) inherits(p1,p2);
+insert into c1 values(1,-1,2);
+alter table p2 add constraint cc check (f2>0); -- fail
+ERROR: check constraint "cc" is violated by some row
+alter table p2 add check (f2>0); -- check it without a name, too
+ERROR: check constraint "p2_f2_check" is violated by some row
+delete from c1;
+insert into c1 values(1,1,2);
+alter table p2 add check (f2>0);
+insert into c1 values(1,-1,2); -- fail
+ERROR: new row for relation "c1" violates check constraint "p2_f2_check"
+create table c2(f3 int) inherits(p1,p2);
+\d c2
+ Table "public.c2"
+ Column | Type | Modifiers
+--------+---------+-----------
+ f1 | integer |
+ f2 | integer |
+ f3 | integer |
+Check constraints:
+ "p2_f2_check" CHECK (f2 > 0)
+Inherits: p1,
+ p2
+
+create table c3 (f4 int) inherits(c1,c2);
+NOTICE: merging multiple inherited definitions of column "f1"
+NOTICE: merging multiple inherited definitions of column "f2"
+NOTICE: merging multiple inherited definitions of column "f3"
+\d c3
+ Table "public.c3"
+ Column | Type | Modifiers
+--------+---------+-----------
+ f1 | integer |
+ f2 | integer |
+ f3 | integer |
+ f4 | integer |
+Check constraints:
+ "p2_f2_check" CHECK (f2 > 0)
+Inherits: c1,
+ c2
+
+drop table p1 cascade;
+NOTICE: drop cascades to 3 other objects
+DETAIL: drop cascades to table c1
+drop cascades to table c2
+drop cascades to table c3
+drop table p2 cascade;
+create table pp1 (f1 int);
+create table cc1 (f2 text, f3 int) inherits (pp1);
+alter table pp1 add column a1 int check (a1 > 0);
+\d cc1
+ Table "public.cc1"
+ Column | Type | Modifiers
+--------+---------+-----------
+ f1 | integer |
+ f2 | text |
+ f3 | integer |
+ a1 | integer |
+Check constraints:
+ "pp1_a1_check" CHECK (a1 > 0)
+Inherits: pp1
+
+create table cc2(f4 float) inherits(pp1,cc1);
+NOTICE: merging multiple inherited definitions of column "f1"
+NOTICE: merging multiple inherited definitions of column "a1"
+\d cc2
+ Table "public.cc2"
+ Column | Type | Modifiers
+--------+------------------+-----------
+ f1 | integer |
+ a1 | integer |
+ f2 | text |
+ f3 | integer |
+ f4 | double precision |
+Check constraints:
+ "pp1_a1_check" CHECK (a1 > 0)
+Inherits: pp1,
+ cc1
+
+alter table pp1 add column a2 int check (a2 > 0);
+NOTICE: merging definition of column "a2" for child "cc2"
+NOTICE: merging constraint "pp1_a2_check" with inherited definition
+\d cc2
+ Table "public.cc2"
+ Column | Type | Modifiers
+--------+------------------+-----------
+ f1 | integer |
+ a1 | integer |
+ f2 | text |
+ f3 | integer |
+ f4 | double precision |
+ a2 | integer |
+Check constraints:
+ "pp1_a1_check" CHECK (a1 > 0)
+ "pp1_a2_check" CHECK (a2 > 0)
+Inherits: pp1,
+ cc1
+
+drop table pp1 cascade;
+NOTICE: drop cascades to 2 other objects
+DETAIL: drop cascades to table cc1
+drop cascades to table cc2
+-- including storage and comments
+CREATE TABLE t1 (a text CHECK (length(a) > 2) PRIMARY KEY, b text);
+NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "t1_pkey" for table "t1"
+CREATE INDEX t1_b_key ON t1 (b);
+CREATE INDEX t1_fnidx ON t1 ((a || b));
+COMMENT ON COLUMN t1.a IS 'A';
+COMMENT ON COLUMN t1.b IS 'B';
+COMMENT ON CONSTRAINT t1_a_check ON t1 IS 't1_a_check';
+COMMENT ON INDEX t1_pkey IS 'index pkey';
+COMMENT ON INDEX t1_b_key IS 'index b_key';
+ALTER TABLE t1 ALTER COLUMN a SET STORAGE MAIN;
+CREATE TABLE t2 (c text);
+ALTER TABLE t2 ALTER COLUMN c SET STORAGE EXTERNAL;
+COMMENT ON COLUMN t2.c IS 'C';
+CREATE TABLE t3 (a text CHECK (length(a) < 5), c text);
+ALTER TABLE t3 ALTER COLUMN c SET STORAGE EXTERNAL;
+ALTER TABLE t3 ALTER COLUMN a SET STORAGE MAIN;
+COMMENT ON COLUMN t3.a IS 'A3';
+COMMENT ON COLUMN t3.c IS 'C';
+COMMENT ON CONSTRAINT t3_a_check ON t3 IS 't3_a_check';
+CREATE TABLE t4 (a text, c text);
+ALTER TABLE t4 ALTER COLUMN c SET STORAGE EXTERNAL;
+CREATE TABLE t12_storage (LIKE t1 INCLUDING STORAGE, LIKE t2 INCLUDING STORAGE);
+\d+ t12_storage
+ Table "public.t12_storage"
+ Column | Type | Modifiers | Storage | Description
+--------+------+-----------+----------+-------------
+ a | text | not null | main |
+ b | text | | extended |
+ c | text | | external |
+Has OIDs: no
+
+CREATE TABLE t12_comments (LIKE t1 INCLUDING COMMENTS, LIKE t2 INCLUDING COMMENTS);
+\d+ t12_comments
+ Table "public.t12_comments"
+ Column | Type | Modifiers | Storage | Description
+--------+------+-----------+----------+-------------
+ a | text | not null | extended | A
+ b | text | | extended | B
+ c | text | | extended | C
+Has OIDs: no
+
+CREATE TABLE t1_inh (LIKE t1 INCLUDING CONSTRAINTS INCLUDING COMMENTS) INHERITS (t1);
+NOTICE: merging column "a" with inherited definition
+NOTICE: merging column "b" with inherited definition
+NOTICE: merging constraint "t1_a_check" with inherited definition
+\d+ t1_inh
+ Table "public.t1_inh"
+ Column | Type | Modifiers | Storage | Description
+--------+------+-----------+----------+-------------
+ a | text | not null | main | A
+ b | text | | extended | B
+Check constraints:
+ "t1_a_check" CHECK (length(a) > 2)
+Inherits: t1
+Has OIDs: no
+
+SELECT description FROM pg_description, pg_constraint c WHERE classoid = 'pg_constraint'::regclass AND objoid = c.oid AND c.conrelid = 't1_inh'::regclass;
+ description
+-------------
+ t1_a_check
+(1 row)
+
+CREATE TABLE t13_inh () INHERITS (t1, t3);
+NOTICE: merging multiple inherited definitions of column "a"
+\d+ t13_inh
+ Table "public.t13_inh"
+ Column | Type | Modifiers | Storage | Description
+--------+------+-----------+----------+-------------
+ a | text | not null | main |
+ b | text | | extended |
+ c | text | | external |
+Check constraints:
+ "t1_a_check" CHECK (length(a) > 2)
+ "t3_a_check" CHECK (length(a) < 5)
+Inherits: t1,
+ t3
+Has OIDs: no
+
+CREATE TABLE t13_like (LIKE t3 INCLUDING CONSTRAINTS INCLUDING COMMENTS INCLUDING STORAGE) INHERITS (t1);
+NOTICE: merging column "a" with inherited definition
+\d+ t13_like
+ Table "public.t13_like"
+ Column | Type | Modifiers | Storage | Description
+--------+------+-----------+----------+-------------
+ a | text | not null | main | A3
+ b | text | | extended |
+ c | text | | external | C
+Check constraints:
+ "t1_a_check" CHECK (length(a) > 2)
+ "t3_a_check" CHECK (length(a) < 5)
+Inherits: t1
+Has OIDs: no
+
+SELECT description FROM pg_description, pg_constraint c WHERE classoid = 'pg_constraint'::regclass AND objoid = c.oid AND c.conrelid = 't13_like'::regclass;
+ description
+-------------
+ t3_a_check
+(1 row)
+
+CREATE TABLE t_all (LIKE t1 INCLUDING ALL);
+NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "t_all_pkey" for table "t_all"
+\d+ t_all
+ Table "public.t_all"
+ Column | Type | Modifiers | Storage | Description
+--------+------+-----------+----------+-------------
+ a | text | not null | main | A
+ b | text | | extended | B
+Indexes:
+ "t_all_pkey" PRIMARY KEY, btree (a)
+ "t_all_b_idx" btree (b)
+ "t_all_expr_idx" btree ((a || b))
+Check constraints:
+ "t1_a_check" CHECK (length(a) > 2)
+Has OIDs: no
+
+SELECT c.relname, objsubid, description FROM pg_description, pg_index i, pg_class c WHERE classoid = 'pg_class'::regclass AND objoid = i.indexrelid AND c.oid = i.indexrelid AND i.indrelid = 't_all'::regclass ORDER BY c.relname, objsubid;
+ relname | objsubid | description
+-------------+----------+-------------
+ t_all_b_idx | 0 | index b_key
+ t_all_pkey | 0 | index pkey
+(2 rows)
+
+CREATE TABLE inh_error1 () INHERITS (t1, t4);
+NOTICE: merging multiple inherited definitions of column "a"
+ERROR: inherited column "a" has a storage parameter conflict
+DETAIL: MAIN versus EXTENDED
+CREATE TABLE inh_error2 (LIKE t4 INCLUDING STORAGE) INHERITS (t1);
+NOTICE: merging column "a" with inherited definition
+ERROR: column "a" has a storage parameter conflict
+DETAIL: MAIN versus EXTENDED
+DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+-- Test for renaming in simple multiple inheritance
+CREATE TABLE t1 (a int, b int);
+CREATE TABLE s1 (b int, c int);
+CREATE TABLE ts (d int) INHERITS (t1, s1);
+NOTICE: merging multiple inherited definitions of column "b"
+ALTER TABLE t1 RENAME a TO aa;
+ALTER TABLE t1 RENAME b TO bb; -- to be failed
+ERROR: cannot rename inherited column "b"
+ALTER TABLE ts RENAME aa TO aaa; -- to be failed
+ERROR: cannot rename inherited column "aa"
+ALTER TABLE ts RENAME d TO dd;
+\d+ ts
+ Table "public.ts"
+ Column | Type | Modifiers | Storage | Description
+--------+---------+-----------+---------+-------------
+ aa | integer | | plain |
+ b | integer | | plain |
+ c | integer | | plain |
+ dd | integer | | plain |
+Inherits: t1,
+ s1
+Has OIDs: no
+
+DROP TABLE ts;
+-- Test for renaming in diamond inheritance
+CREATE TABLE t2 (x int) INHERITS (t1);
+CREATE TABLE t3 (y int) INHERITS (t1);
+CREATE TABLE t4 (z int) INHERITS (t2, t3);
+NOTICE: merging multiple inherited definitions of column "aa"
+NOTICE: merging multiple inherited definitions of column "b"
+ALTER TABLE t1 RENAME aa TO aaa;
+\d+ t4
+ Table "public.t4"
+ Column | Type | Modifiers | Storage | Description
+--------+---------+-----------+---------+-------------
+ aaa | integer | | plain |
+ b | integer | | plain |
+ x | integer | | plain |
+ y | integer | | plain |
+ z | integer | | plain |
+Inherits: t2,
+ t3
+Has OIDs: no
+
+CREATE TABLE ts (d int) INHERITS (t2, s1);
+NOTICE: merging multiple inherited definitions of column "b"
+ALTER TABLE t1 RENAME aaa TO aaaa;
+ALTER TABLE t1 RENAME b TO bb; -- to be failed
+ERROR: cannot rename inherited column "b"
+\d+ ts
+ Table "public.ts"
+ Column | Type | Modifiers | Storage | Description
+--------+---------+-----------+---------+-------------
+ aaaa | integer | | plain |
+ b | integer | | plain |
+ x | integer | | plain |
+ c | integer | | plain |
+ d | integer | | plain |
+Inherits: t2,
+ s1
+Has OIDs: no
+
+WITH RECURSIVE r AS (
+ SELECT 't1'::regclass AS inhrelid
+UNION ALL
+ SELECT c.inhrelid FROM pg_inherits c, r WHERE r.inhrelid = c.inhparent
+)
+SELECT a.attrelid::regclass, a.attname, a.attinhcount, e.expected
+ FROM (SELECT inhrelid, count(*) AS expected FROM pg_inherits
+ WHERE inhparent IN (SELECT inhrelid FROM r) GROUP BY inhrelid) e
+ JOIN pg_attribute a ON e.inhrelid = a.attrelid WHERE NOT attislocal
+ ORDER BY a.attrelid::regclass::name, a.attnum;
+ attrelid | attname | attinhcount | expected
+----------+---------+-------------+----------
+ t2 | aaaa | 1 | 1
+ t2 | b | 1 | 1
+ t3 | aaaa | 1 | 1
+ t3 | b | 1 | 1
+ t4 | aaaa | 2 | 2
+ t4 | b | 2 | 2
+ t4 | x | 1 | 2
+ t4 | y | 1 | 2
+ ts | aaaa | 1 | 1
+ ts | b | 2 | 1
+ ts | x | 1 | 1
+ ts | c | 1 | 1
+(12 rows)
+
+DROP TABLE t1, s1 CASCADE;
+NOTICE: drop cascades to 4 other objects
+DETAIL: drop cascades to table t2
+drop cascades to table ts
+drop cascades to table t3
+drop cascades to table t4
+--
+-- Test merge-append plans for inheritance trees
+--
+create table matest0 (id serial primary key, name text);
+NOTICE: CREATE TABLE will create implicit sequence "matest0_id_seq" for serial column "matest0.id"
+NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "matest0_pkey" for table "matest0"
+create table matest1 (id integer primary key) inherits (matest0);
+NOTICE: merging column "id" with inherited definition
+NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "matest1_pkey" for table "matest1"
+create table matest2 (id integer primary key) inherits (matest0);
+NOTICE: merging column "id" with inherited definition
+NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "matest2_pkey" for table "matest2"
+create table matest3 (id integer primary key) inherits (matest0);
+NOTICE: merging column "id" with inherited definition
+NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "matest3_pkey" for table "matest3"
+create index matest0i on matest0 ((1-id));
+create index matest1i on matest1 ((1-id));
+-- create index matest2i on matest2 ((1-id)); -- intentionally missing
+create index matest3i on matest3 ((1-id));
+insert into matest1 (name) values ('Test 1');
+insert into matest1 (name) values ('Test 2');
+insert into matest2 (name) values ('Test 3');
+insert into matest2 (name) values ('Test 4');
+insert into matest3 (name) values ('Test 5');
+insert into matest3 (name) values ('Test 6');
+set enable_indexscan = off; -- force use of seqscan/sort, so no merge
+explain (verbose, costs off) select * from matest0 order by 1-id;
+ QUERY PLAN
+---------------------------------------------------------------------------------
+ Sort
+ Output: public.matest0.id, public.matest0.name, ((1 - public.matest0.id))
+ Sort Key: ((1 - public.matest0.id))
+ -> Result
+ Output: public.matest0.id, public.matest0.name, (1 - public.matest0.id)
+ -> Append
+ -> Seq Scan on public.matest0
+ Output: public.matest0.id, public.matest0.name
+ -> Seq Scan on public.matest1 matest0
+ Output: public.matest0.id, public.matest0.name
+ -> Seq Scan on public.matest2 matest0
+ Output: public.matest0.id, public.matest0.name
+ -> Seq Scan on public.matest3 matest0
+ Output: public.matest0.id, public.matest0.name
+(14 rows)
+
+select * from matest0 order by 1-id;
+ id | name
+----+--------
+ 6 | Test 6
+ 5 | Test 5
+ 4 | Test 4
+ 3 | Test 3
+ 2 | Test 2
+ 1 | Test 1
+(6 rows)
+
+reset enable_indexscan;
+set enable_seqscan = off; -- plan with fewest seqscans should be merge
+explain (verbose, costs off) select * from matest0 order by 1-id;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------
+ Result
+ Output: public.matest0.id, public.matest0.name, ((1 - public.matest0.id))
+ -> Merge Append
+ Sort Key: ((1 - public.matest0.id))
+ -> Index Scan using matest0i on public.matest0
+ Output: public.matest0.id, public.matest0.name, (1 - public.matest0.id)
+ -> Index Scan using matest1i on public.matest1 matest0
+ Output: public.matest0.id, public.matest0.name, (1 - public.matest0.id)
+ -> Sort
+ Output: public.matest0.id, public.matest0.name, ((1 - public.matest0.id))
+ Sort Key: ((1 - public.matest0.id))
+ -> Seq Scan on public.matest2 matest0
+ Output: public.matest0.id, public.matest0.name, (1 - public.matest0.id)
+ -> Index Scan using matest3i on public.matest3 matest0
+ Output: public.matest0.id, public.matest0.name, (1 - public.matest0.id)
+(15 rows)
+
+select * from matest0 order by 1-id;
+ id | name
+----+--------
+ 6 | Test 6
+ 5 | Test 5
+ 4 | Test 4
+ 3 | Test 3
+ 2 | Test 2
+ 1 | Test 1
+(6 rows)
+
+reset enable_seqscan;
+drop table matest0 cascade;
+NOTICE: drop cascades to 3 other objects
+DETAIL: drop cascades to table matest1
+drop cascades to table matest2
+drop cascades to table matest3
diff --git a/src/test/regress/sql/inherit.sql b/src/test/regress/sql/inherit.sql
index 7b0851b0d4..8f7d12476f 100644
--- a/src/test/regress/sql/inherit.sql
+++ b/src/test/regress/sql/inherit.sql
@@ -42,6 +42,15 @@ SELECT relname, a.* FROM ONLY a, pg_class where a.tableoid = pg_class.oid ORDER
SELECT relname, b.* FROM ONLY b, pg_class where b.tableoid = pg_class.oid ORDER BY relname, b.aa;
SELECT relname, c.* FROM ONLY c, pg_class where c.tableoid = pg_class.oid ORDER BY relname, c.aa;
SELECT relname, d.* FROM ONLY d, pg_class where d.tableoid = pg_class.oid ORDER BY relname, d.aa;
+-- In Postgres-XC, Oids are not consistent among nodes, but a cast on relation can be used for global operations on Oid
+SELECT relname, a.* FROM a, pg_class WHERE 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+SELECT relname, b.* FROM b, pg_class WHERE 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+SELECT relname, c.* FROM c, pg_class WHERE 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+SELECT relname, d.* FROM d, pg_class WHERE 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
+SELECT relname, a.* FROM ONLY a, pg_class where 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+SELECT relname, b.* FROM ONLY b, pg_class where 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+SELECT relname, c.* FROM ONLY c, pg_class where 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+SELECT relname, d.* FROM ONLY d, pg_class where 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
UPDATE a SET aa='zzzz' WHERE aa='aaaa';
UPDATE ONLY a SET aa='zzzzz' WHERE aa='aaaaa';
@@ -57,6 +66,15 @@ SELECT relname, a.* FROM ONLY a, pg_class where a.tableoid = pg_class.oid ORDER
SELECT relname, b.* FROM ONLY b, pg_class where b.tableoid = pg_class.oid ORDER BY relname, b.aa;
SELECT relname, c.* FROM ONLY c, pg_class where c.tableoid = pg_class.oid ORDER BY relname, c.aa;
SELECT relname, d.* FROM ONLY d, pg_class where d.tableoid = pg_class.oid ORDER BY relname, d.aa;
+-- In Postgres-XC, Oids are not consistent among nodes, but a cast on relation can be used for global operations on Oid
+SELECT relname, a.* FROM a, pg_class WHERE 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+SELECT relname, b.* FROM b, pg_class WHERE 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+SELECT relname, c.* FROM c, pg_class WHERE 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+SELECT relname, d.* FROM d, pg_class WHERE 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
+SELECT relname, a.* FROM ONLY a, pg_class where 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+SELECT relname, b.* FROM ONLY b, pg_class where 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+SELECT relname, c.* FROM ONLY c, pg_class where 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+SELECT relname, d.* FROM ONLY d, pg_class where 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
UPDATE b SET aa='new';
@@ -68,6 +86,15 @@ SELECT relname, a.* FROM ONLY a, pg_class where a.tableoid = pg_class.oid ORDER
SELECT relname, b.* FROM ONLY b, pg_class where b.tableoid = pg_class.oid ORDER BY relname, b.aa;
SELECT relname, c.* FROM ONLY c, pg_class where c.tableoid = pg_class.oid ORDER BY relname, c.aa;
SELECT relname, d.* FROM ONLY d, pg_class where d.tableoid = pg_class.oid ORDER BY relname, d.aa;
+-- In Postgres-XC, Oids are not consistent among nodes, but a cast on relation can be used for global operations on Oid
+SELECT relname, a.* FROM a, pg_class WHERE 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+SELECT relname, b.* FROM b, pg_class WHERE 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+SELECT relname, c.* FROM c, pg_class WHERE 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+SELECT relname, d.* FROM d, pg_class WHERE 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
+SELECT relname, a.* FROM ONLY a, pg_class where 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+SELECT relname, b.* FROM ONLY b, pg_class where 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+SELECT relname, c.* FROM ONLY c, pg_class where 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+SELECT relname, d.* FROM ONLY d, pg_class where 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
UPDATE a SET aa='new';
@@ -81,6 +108,15 @@ SELECT relname, a.* FROM ONLY a, pg_class where a.tableoid = pg_class.oid ORDER
SELECT relname, b.* FROM ONLY b, pg_class where b.tableoid = pg_class.oid ORDER BY relname, b.aa;
SELECT relname, c.* FROM ONLY c, pg_class where c.tableoid = pg_class.oid ORDER BY relname, c.aa;
SELECT relname, d.* FROM ONLY d, pg_class where d.tableoid = pg_class.oid ORDER BY relname, d.aa;
+-- In Postgres-XC, Oids are not consistent among nodes, but a cast on relation can be used for global operations on Oid
+SELECT relname, a.* FROM a, pg_class WHERE 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+SELECT relname, b.* FROM b, pg_class WHERE 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+SELECT relname, c.* FROM c, pg_class WHERE 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+SELECT relname, d.* FROM d, pg_class WHERE 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
+SELECT relname, a.* FROM ONLY a, pg_class where 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+SELECT relname, b.* FROM ONLY b, pg_class where 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+SELECT relname, c.* FROM ONLY c, pg_class where 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+SELECT relname, d.* FROM ONLY d, pg_class where 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
DELETE FROM a;
@@ -92,6 +128,15 @@ SELECT relname, a.* FROM ONLY a, pg_class where a.tableoid = pg_class.oid ORDER
SELECT relname, b.* FROM ONLY b, pg_class where b.tableoid = pg_class.oid ORDER BY relname, b.aa;
SELECT relname, c.* FROM ONLY c, pg_class where c.tableoid = pg_class.oid ORDER BY relname, c.aa;
SELECT relname, d.* FROM ONLY d, pg_class where d.tableoid = pg_class.oid ORDER BY relname, d.aa;
+-- In Postgres-XC, Oids are not consistent among nodes, but a cast on relation can be used for global operations on Oid
+SELECT relname, a.* FROM a, pg_class WHERE 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+SELECT relname, b.* FROM b, pg_class WHERE 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+SELECT relname, c.* FROM c, pg_class WHERE 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+SELECT relname, d.* FROM d, pg_class WHERE 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
+SELECT relname, a.* FROM ONLY a, pg_class where 'a'::regclass = pg_class.oid ORDER BY relname, a.aa;
+SELECT relname, b.* FROM ONLY b, pg_class where 'b'::regclass = pg_class.oid ORDER BY relname, b.aa;
+SELECT relname, c.* FROM ONLY c, pg_class where 'c'::regclass = pg_class.oid ORDER BY relname, c.aa;
+SELECT relname, d.* FROM ONLY d, pg_class where 'd'::regclass = pg_class.oid ORDER BY relname, d.aa;
-- Confirm PRIMARY KEY adds NOT NULL constraint to child table
CREATE TEMP TABLE z (b TEXT, PRIMARY KEY(aa, b)) inherits (a);
generated by cgit v1.2.3 (git 2.39.1) at 2025-07-12 07:04:21 +0000