[#26576] YSQL: Enable table inheritance for all ported tests

Summary:
Setting the defaults for `BasePgRegressTestPorted` to match more closely with Postgres behaviour will help simplify efforts to port more Postgres tests.

5aea237 / D42034 enabled inheritance on Yugabyte, but did not update all of the regression tests. This diff sets `ysql_enable_inheritance=true` for all tests that derive from `BasePgRegressTestPorted`. This cascades into some changes:
* any Java test deriving from this class doesn't need to explicitly set the flag anymore.
* regress tests that use table inheritance no longer have an error in their output. Many of these tests have a comment similar to "TODO: port more once inheritance is enabled".  Generally, uncommenting the following lines results in the expected output. This change touches only lines related to `INHERITS`, and does not attempt to re-port other sections of the affected files.
* `yb_enable_read_committed_isolation` is also now enabled by default in `BasePgRegressTestPorted` to enable some new test cases. This does not set the isolation level to read committed, but just **allows** it to be set.

To help review, it's helpful to diff the `yb.port.*.sql` and `yb.port.*.out` files with their sources.
```
function portdiffsql() {
  diff src/postgres/src/test/regress/sql/$1.sql src/postgres/src/test/regress/sql/yb.port.$1.sql
}
function portdiffout() {
  diff src/postgres/src/test/regress/expected/$1.out src/postgres/src/test/regress/expected/yb.port.$1.out
}
portdiffsql foreign_data
portdiffsql foreign_key
portdiffsql generated
portdiffsql insert_conflict
portdiffsql privileges
portdiffsql rowsecurity
portdiffsql truncate

portdiffout foreign_data
portdiffout foreign_key
portdiffout generated
portdiffout insert_conflict
portdiffout privileges
portdiffout rowsecurity
portdiffout truncate
```

Differences worth calling out:
* There are a few cases where we need to delete + reinsert rows to get match the ctid update behaviour of Postgres
* `yb.port.foreign_key` has extra changes because indexes on `INET` are not supported.
* `yb.port.truncate` has some tests for `TRUNCATE ONLY` that depend on `TRUNCATE` being transactional. It's not transactional in YB,  so to keep the coverage of `TRUNCATE ONLY`, manually reset the table after each `ROLLBACK`. (lines ~1640 in yb.port.truncate.sql`). The results of the `SELECT`s are identical to PG.
Jira: DB-15944

Test Plan:
```
./yb_build.sh --java-test TestPgRegressPgAuth
./yb_build.sh --java-test TestPgRegressPgDml
./yb_build.sh --java-test TestPgRegressPgForeignData
./yb_build.sh --java-test TestPgRegressPgGenerated
./yb_build.sh --java-test TestPgRegressPgMiscIndependent
./yb_build.sh --java-test TestPgRegressForeignKey
```

Jenkins

Reviewers: fizaa, sanketh

Reviewed By: sanketh

Subscribers: smishra, yql

Differential Revision: https://phorge.dev.yugabyte.com/D42816

Author: timothy-e

java/yb-pgsql/src/test/java/org/yb/pgsql/BasePgRegressTestPorted.java

@@ -26,6 +26,8 @@ public class BasePgRegressTestPorted extends BasePgRegressTest {
   protected Map<String, String> getTServerFlags() {
     Map<String, String> flagMap = super.getTServerFlags();
     flagMap.put("TEST_generate_ybrowid_sequentially", "true");
+    flagMap.put("ysql_enable_inheritance", "true");
+    flagMap.put("yb_enable_read_committed_isolation", "true");
     appendToYsqlPgConf(flagMap, "yb_use_hash_splitting_by_default=false");
     return flagMap;
   }

java/yb-pgsql/src/test/java/org/yb/pgsql/TestPgRegressContribPostgresFdw.java

@@ -18,6 +18,7 @@
 import org.yb.YBTestRunner;
 
 import java.io.File;
+import java.util.Map;
 
 @RunWith(value=YBTestRunner.class)
 public class TestPgRegressContribPostgresFdw extends BasePgRegressTestPorted {
@@ -31,4 +32,14 @@ public void schedule() throws Exception {
     runPgRegressTest(new File(TestUtils.getBuildRootDir(), "postgres_build/contrib/postgres_fdw"),
                      "yb_schedule");
   }
+
+  /* TODO: this is necessary because the ysql_enable_inheritance can leak into other tests and cause
+   * failures. This test should use BasePgRegressTestPorted, and this flag can be removed.
+   */
+  @Override
+  protected Map<String, String> getTServerFlags() {
+    Map<String, String> flagMap = super.getTServerFlags();
+    flagMap.put("ysql_enable_inheritance", "false");
+    return flagMap;
+  }
 }

java/yb-pgsql/src/test/java/org/yb/pgsql/TestPgRegressInherit.java

@@ -21,13 +21,6 @@
 @RunWith(value=YBTestRunner.class)
 public class TestPgRegressInherit extends BasePgRegressTestPorted {
 
-  @Override
-  protected Map<String, String> getTServerFlags() {
-    Map<String, String> flags = super.getTServerFlags();
-    flags.put("ysql_enable_inheritance", "true");
-    return flags;
-  }
-
   @Test
   public void testPgRegressInherit() throws Exception {
     runPgRegressTest("yb_pg_inherit_schedule");

java/yb-pgsql/src/test/java/org/yb/pgsql/TestPgRegressLimit.java

@@ -27,13 +27,6 @@ public int getTestMethodTimeoutSec() {
     return 1800;
   }
 
-  @Override
-  protected Map<String, String> getTServerFlags() {
-    Map<String, String> flags = super.getTServerFlags();
-    flags.put("ysql_enable_inheritance", "true");
-    return flags;
-  }
-
   @Test
   public void testPgRegressYbFetchLimits() throws Exception {
     runPgRegressTest("yb_limit_schedule");

java/yb-pgsql/src/test/java/org/yb/pgsql/TestPgRegressPgConstraints.java

@@ -27,13 +27,6 @@ public int getTestMethodTimeoutSec() {
         return 1800;
     }
 
-    @Override
-    protected Map<String, String> getTServerFlags() {
-      Map<String, String> flags = super.getTServerFlags();
-      flags.put("ysql_enable_inheritance", "true");
-      return flags;
-    }
-
     @Test
     public void schedule() throws Exception {
         runPgRegressTest("yb_pg_constraints_schedule");

java/yb-pgsql/src/test/java/org/yb/pgsql/TestPgRegressPgMisc.java

@@ -29,14 +29,6 @@ public int getTestMethodTimeoutSec() {
     return 1800;
   }
 
-
-  @Override
-  protected Map<String, String> getTServerFlags() {
-    Map<String, String> flags = super.getTServerFlags();
-    flags.put("ysql_enable_inheritance", "true");
-    return flags;
-  }
-
   @Test
   public void testPgRegressPgMisc() throws Exception {
     runPgRegressTest("yb_pg_misc_serial_schedule");

src/postgres/src/test/regress/expected/yb.port.foreign_data.out

@@ -866,57 +866,59 @@ CREATE TABLE PKTABLE (ptest1 int, ptest2 text, ptest3 int, ptest4 text, PRIMARY
 ptest3) REFERENCES pktable);
 ERROR:  foreign key constraint "pktable_ptest4_ptest3_fkey" cannot be implemented
 DETAIL:  Key columns "ptest4" and "ptest1" are of incompatible types: text and integer.
--- TODO: YugaByte does not yet support table inheritance.
---       Leaving the first failing statement uncommented so that this test
---       will fail when the feature is implemented (the full test should
---       be uncommented then).
 --
 -- Now some cases with inheritance
 -- Basic 2 table case: 1 column of matching types.
 create table pktable_base (base1 int not null);
 create table pktable (ptest1 int, primary key(base1), unique(base1, ptest1)) inherits (pktable_base);
-ERROR:  INHERITS not supported yet
-LINE 1: ...1 int, primary key(base1), unique(base1, ptest1)) inherits (...
-                                                             ^
-HINT:  See https://github.com/yugabyte/yugabyte-db/issues/1129. React with thumbs up to raise its priority
-/*
 create table fktable (ftest1 int references pktable(base1));
 -- now some ins, upd, del
 insert into pktable(base1) values (1);
 insert into pktable(base1) values (2);
 --  let's insert a non-existent fktable value
 insert into fktable(ftest1) values (3);
+ERROR:  insert or update on table "fktable" violates foreign key constraint "fktable_ftest1_fkey"
+DETAIL:  Key (ftest1)=(3) is not present in table "pktable".
 --  let's make a valid row for that
 insert into pktable(base1) values (3);
 insert into fktable(ftest1) values (3);
 -- let's try removing a row that should fail from pktable
 delete from pktable where base1>2;
+ERROR:  update or delete on table "pktable" violates foreign key constraint "fktable_ftest1_fkey" on table "fktable"
+DETAIL:  Key (base1)=(3) is still referenced from table "fktable".
 -- okay, let's try updating all of the base1 values to *4
 -- which should fail.
 update pktable set base1=base1*4;
+ERROR:  update or delete on table "pktable" violates foreign key constraint "fktable_ftest1_fkey" on table "fktable"
+DETAIL:  Key (base1)=(3) is still referenced from table "fktable".
 -- okay, let's try an update that should work.
 update pktable set base1=base1*4 where base1<3;
 -- and a delete that should work
 delete from pktable where base1>3;
 -- cleanup
 drop table fktable;
 delete from pktable;
-
 -- Now 2 columns 2 tables, matching types
 create table fktable (ftest1 int, ftest2 int, foreign key(ftest1, ftest2) references pktable(base1, ptest1));
 -- now some ins, upd, del
 insert into pktable(base1, ptest1) values (1, 1);
 insert into pktable(base1, ptest1) values (2, 2);
 --  let's insert a non-existent fktable value
 insert into fktable(ftest1, ftest2) values (3, 1);
+ERROR:  insert or update on table "fktable" violates foreign key constraint "fktable_ftest1_ftest2_fkey"
+DETAIL:  Key (ftest1, ftest2)=(3, 1) is not present in table "pktable".
 --  let's make a valid row for that
 insert into pktable(base1,ptest1) values (3, 1);
 insert into fktable(ftest1, ftest2) values (3, 1);
 -- let's try removing a row that should fail from pktable
 delete from pktable where base1>2;
+ERROR:  update or delete on table "pktable" violates foreign key constraint "fktable_ftest1_ftest2_fkey" on table "fktable"
+DETAIL:  Key (base1, ptest1)=(3, 1) is still referenced from table "fktable".
 -- okay, let's try updating all of the base1 values to *4
 -- which should fail.
 update pktable set base1=base1*4;
+ERROR:  update or delete on table "pktable" violates foreign key constraint "fktable_ftest1_ftest2_fkey" on table "fktable"
+DETAIL:  Key (base1, ptest1)=(3, 1) is still referenced from table "fktable".
 -- okay, let's try an update that should work.
 update pktable set base1=base1*4 where base1<3;
 -- and a delete that should work
@@ -925,7 +927,6 @@ delete from pktable where base1>3;
 drop table fktable;
 drop table pktable;
 drop table pktable_base;
-
 -- Now we'll do one all in 1 table with 2 columns of matching types
 create table pktable_base(base1 int not null, base2 int);
 create table pktable(ptest1 int, ptest2 int, primary key(base1, ptest1), foreign key(base2, ptest2) references
@@ -936,41 +937,63 @@ insert into pktable (base1, ptest1, base2, ptest2) values (2, 2, 2, 1);
 insert into pktable (base1, ptest1, base2, ptest2) values (1, 3, 2, 2);
 -- fails (3,2) isn't in base1, ptest1
 insert into pktable (base1, ptest1, base2, ptest2) values (2, 3, 3, 2);
+ERROR:  insert or update on table "pktable" violates foreign key constraint "pktable_base2_ptest2_fkey"
+DETAIL:  Key (base2, ptest2)=(3, 2) is not present in table "pktable".
 -- fails (2,2) is being referenced
 delete from pktable where base1=2;
+ERROR:  update or delete on table "pktable" violates foreign key constraint "pktable_base2_ptest2_fkey" on table "pktable"
+DETAIL:  Key (base1, ptest1)=(2, 2) is still referenced from table "pktable".
 -- fails (1,1) is being referenced (twice)
 update pktable set base1=3 where base1=1;
+ERROR:  update or delete on table "pktable" violates foreign key constraint "pktable_base2_ptest2_fkey" on table "pktable"
+DETAIL:  Key (base1, ptest1)=(1, 1) is still referenced from table "pktable".
 -- this sequence of two deletes will work, since after the first there will be no (2,*) references
 delete from pktable where base2=2;
 delete from pktable where base1=2;
 drop table pktable;
 drop table pktable_base;
-
 -- 2 columns (2 tables), mismatched types
 create table pktable_base(base1 int not null);
-create table pktable(ptest1 inet, primary key(base1, ptest1)) inherits (pktable_base);
+create table pktable(ptest1 text, primary key(base1, ptest1)) inherits (pktable_base); -- YB: #17017: replace INET with TEXT because indexes on INET are not supported
 -- just generally bad types (with and without column references on the referenced table)
 create table fktable(ftest1 cidr, ftest2 int[], foreign key (ftest1, ftest2) references pktable);
+ERROR:  foreign key constraint "fktable_ftest1_ftest2_fkey" cannot be implemented
+DETAIL:  Key columns "ftest1" and "base1" are of incompatible types: cidr and integer.
 create table fktable(ftest1 cidr, ftest2 int[], foreign key (ftest1, ftest2) references pktable(base1, ptest1));
+ERROR:  foreign key constraint "fktable_ftest1_ftest2_fkey" cannot be implemented
+DETAIL:  Key columns "ftest1" and "base1" are of incompatible types: cidr and integer.
 -- let's mix up which columns reference which
 create table fktable(ftest1 int, ftest2 inet, foreign key(ftest2, ftest1) references pktable);
+ERROR:  foreign key constraint "fktable_ftest2_ftest1_fkey" cannot be implemented
+DETAIL:  Key columns "ftest2" and "base1" are of incompatible types: inet and integer.
 create table fktable(ftest1 int, ftest2 inet, foreign key(ftest2, ftest1) references pktable(base1, ptest1));
+ERROR:  foreign key constraint "fktable_ftest2_ftest1_fkey" cannot be implemented
+DETAIL:  Key columns "ftest2" and "base1" are of incompatible types: inet and integer.
 create table fktable(ftest1 int, ftest2 inet, foreign key(ftest1, ftest2) references pktable(ptest1, base1));
+ERROR:  foreign key constraint "fktable_ftest1_ftest2_fkey" cannot be implemented
+DETAIL:  Key columns "ftest1" and "ptest1" are of incompatible types: integer and text.
 drop table pktable;
 drop table pktable_base;
-
 -- 2 columns (1 table), mismatched types
 create table pktable_base(base1 int not null, base2 int);
-create table pktable(ptest1 inet, ptest2 inet[], primary key(base1, ptest1), foreign key(base2, ptest2) references
+create table pktable(ptest1 text, ptest2 text[], primary key(base1, ptest1), foreign key(base2, ptest2) references -- YB: #17017: replace INET with TEXT because indexes on INET are not supported
                                              pktable(base1, ptest1)) inherits (pktable_base);
-create table pktable(ptest1 inet, ptest2 inet, primary key(base1, ptest1), foreign key(base2, ptest2) references
+ERROR:  foreign key constraint "pktable_base2_ptest2_fkey" cannot be implemented
+DETAIL:  Key columns "ptest2" and "ptest1" are of incompatible types: text[] and text.
+create table pktable(ptest1 text, ptest2 text, primary key(base1, ptest1), foreign key(base2, ptest2) references -- YB: #17017: replace INET with TEXT because indexes on INET are not supported
                                              pktable(ptest1, base1)) inherits (pktable_base);
-create table pktable(ptest1 inet, ptest2 inet, primary key(base1, ptest1), foreign key(ptest2, base2) references
+ERROR:  foreign key constraint "pktable_base2_ptest2_fkey" cannot be implemented
+DETAIL:  Key columns "base2" and "ptest1" are of incompatible types: integer and text.
+create table pktable(ptest1 text, ptest2 text, primary key(base1, ptest1), foreign key(ptest2, base2) references -- YB: #17017: replace INET with TEXT because indexes on INET are not supported
                                              pktable(base1, ptest1)) inherits (pktable_base);
-create table pktable(ptest1 inet, ptest2 inet, primary key(base1, ptest1), foreign key(ptest2, base2) references
+ERROR:  foreign key constraint "pktable_ptest2_base2_fkey" cannot be implemented
+DETAIL:  Key columns "ptest2" and "base1" are of incompatible types: text and integer.
+create table pktable(ptest1 text, ptest2 text, primary key(base1, ptest1), foreign key(ptest2, base2) references -- YB: #17017: replace INET with TEXT because indexes on INET are not supported
                                              pktable(base1, ptest1)) inherits (pktable_base);
+ERROR:  foreign key constraint "pktable_ptest2_base2_fkey" cannot be implemented
+DETAIL:  Key columns "ptest2" and "base1" are of incompatible types: text and integer.
 drop table pktable;
-*/
+ERROR:  table "pktable" does not exist
 drop table pktable_base;
 --
 -- Deferrable constraints