src/test/regress/expected/index_including_optimizer.out - cloudberry - Git at Google

 /*
  * 1.test CREATE INDEX
  *
  * Deliberately avoid dropping objects in this section, to get some pg_dump
  * coverage.
  */
 -- Regular index with included columns
 CREATE TABLE tbl_include_reg (c1 int, c2 int, c3 int, c4 box);
 INSERT INTO tbl_include_reg SELECT x, 2*x, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
 CREATE INDEX tbl_include_reg_idx ON tbl_include_reg (c1, c2) INCLUDE (c3, c4);
 -- duplicate column is pretty pointless, but we allow it anyway
 CREATE INDEX ON tbl_include_reg (c1, c2) INCLUDE (c1, c3);
 SELECT pg_get_indexdef(i.indexrelid)
 FROM pg_index i JOIN pg_class c ON i.indexrelid = c.oid
 WHERE i.indrelid = 'tbl_include_reg'::regclass ORDER BY c.relname;
                                                 pg_get_indexdef
 ---------------------------------------------------------------------------------------------------------------
  CREATE INDEX tbl_include_reg_c1_c2_c11_c3_idx ON public.tbl_include_reg USING btree (c1, c2) INCLUDE (c1, c3)
  CREATE INDEX tbl_include_reg_idx ON public.tbl_include_reg USING btree (c1, c2) INCLUDE (c3, c4)
 (2 rows)

 \d tbl_include_reg_idx
   Index "public.tbl_include_reg_idx"
  Column |  Type   | Key? | Definition
 --------+---------+------+------------
  c1     | integer | yes  | c1
  c2     | integer | yes  | c2
  c3     | integer | no   | c3
  c4     | box     | no   | c4
 btree, for table "public.tbl_include_reg"

 -- Unique index and unique constraint
 CREATE TABLE tbl_include_unique1 (c1 int, c2 int, c3 int, c4 box);
 INSERT INTO tbl_include_unique1 SELECT x, 2*x, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
 CREATE UNIQUE INDEX tbl_include_unique1_idx_unique ON tbl_include_unique1 using btree (c1, c2) INCLUDE (c3, c4);
 ALTER TABLE tbl_include_unique1 add UNIQUE USING INDEX tbl_include_unique1_idx_unique;
 ALTER TABLE tbl_include_unique1 add UNIQUE (c1, c2) INCLUDE (c3, c4);
 SELECT pg_get_indexdef(i.indexrelid)
 FROM pg_index i JOIN pg_class c ON i.indexrelid = c.oid
 WHERE i.indrelid = 'tbl_include_unique1'::regclass ORDER BY c.relname;
                                                        pg_get_indexdef
 -----------------------------------------------------------------------------------------------------------------------------
  CREATE UNIQUE INDEX tbl_include_unique1_c1_c2_c3_c4_key ON public.tbl_include_unique1 USING btree (c1, c2) INCLUDE (c3, c4)
  CREATE UNIQUE INDEX tbl_include_unique1_idx_unique ON public.tbl_include_unique1 USING btree (c1, c2) INCLUDE (c3, c4)
 (2 rows)

 -- Unique index and unique constraint. Both must fail.
 CREATE TABLE tbl_include_unique2 (c1 int, c2 int, c3 int, c4 box);
 INSERT INTO tbl_include_unique2 SELECT 1, 2, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
 CREATE UNIQUE INDEX tbl_include_unique2_idx_unique ON tbl_include_unique2 using btree (c1, c2) INCLUDE (c3, c4);
 ERROR:  could not create unique index "tbl_include_unique2_idx_unique"
 DETAIL:  Key (c1, c2)=(1, 2) is duplicated.
 ALTER TABLE tbl_include_unique2 add UNIQUE (c1, c2) INCLUDE (c3, c4);
 ERROR:  could not create unique index "tbl_include_unique2_c1_c2_c3_c4_key"
 DETAIL:  Key (c1, c2)=(1, 2) is duplicated.
 -- PK constraint
 CREATE TABLE tbl_include_pk (c1 int, c2 int, c3 int, c4 box);
 INSERT INTO tbl_include_pk SELECT 1, 2*x, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
 ALTER TABLE tbl_include_pk add PRIMARY KEY (c1, c2) INCLUDE (c3, c4);
 SELECT pg_get_indexdef(i.indexrelid)
 FROM pg_index i JOIN pg_class c ON i.indexrelid = c.oid
 WHERE i.indrelid = 'tbl_include_pk'::regclass ORDER BY c.relname;
                                             pg_get_indexdef
 --------------------------------------------------------------------------------------------------------
  CREATE UNIQUE INDEX tbl_include_pk_pkey ON public.tbl_include_pk USING btree (c1, c2) INCLUDE (c3, c4)
 (1 row)

 CREATE TABLE tbl_include_box (c1 int, c2 int, c3 int, c4 box);
 INSERT INTO tbl_include_box SELECT 1, 2*x, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
 CREATE UNIQUE INDEX tbl_include_box_idx_unique ON tbl_include_box using btree (c1, c2) INCLUDE (c3, c4);
 ALTER TABLE tbl_include_box add PRIMARY KEY USING INDEX tbl_include_box_idx_unique;
 SELECT pg_get_indexdef(i.indexrelid)
 FROM pg_index i JOIN pg_class c ON i.indexrelid = c.oid
 WHERE i.indrelid = 'tbl_include_box'::regclass ORDER BY c.relname;
                                                 pg_get_indexdef
 ----------------------------------------------------------------------------------------------------------------
  CREATE UNIQUE INDEX tbl_include_box_idx_unique ON public.tbl_include_box USING btree (c1, c2) INCLUDE (c3, c4)
 (1 row)

 -- PK constraint. Must fail.
 CREATE TABLE tbl_include_box_pk (c1 int, c2 int, c3 int, c4 box);
 INSERT INTO tbl_include_box_pk SELECT 1, 2, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
 ALTER TABLE tbl_include_box_pk add PRIMARY KEY (c1, c2) INCLUDE (c3, c4);
 ERROR:  could not create unique index "tbl_include_box_pk_pkey"
 DETAIL:  Key (c1, c2)=(1, 2) is duplicated.
 /*
  * 2. Test CREATE TABLE with constraint
  */
 CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box,
 				CONSTRAINT covering UNIQUE(c1,c2) INCLUDE(c3,c4));
 SELECT indexrelid::regclass, indnatts, indnkeyatts, indisunique, indisprimary, indkey, indclass FROM pg_index WHERE indrelid = 'tbl'::regclass::oid;
  indexrelid | indnatts | indnkeyatts | indisunique | indisprimary | indkey  | indclass
 ------------+----------+-------------+-------------+--------------+---------+-----------
  covering   |        4 |           2 | t           | f            | 1 2 3 4 | 1978 1978
 (1 row)

 SELECT pg_get_constraintdef(oid), conname, conkey FROM pg_constraint WHERE conrelid = 'tbl'::regclass::oid;
        pg_get_constraintdef       | conname  | conkey
 ----------------------------------+----------+--------
  UNIQUE (c1, c2) INCLUDE (c3, c4) | covering | {1,2}
 (1 row)

 -- ensure that constraint works
 INSERT INTO tbl SELECT 1, 2, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
 ERROR:  duplicate key value violates unique constraint "covering"
 DETAIL:  Key (c1, c2)=(1, 2) already exists.
 DROP TABLE tbl;
 CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box,
 				CONSTRAINT covering PRIMARY KEY(c1,c2) INCLUDE(c3,c4));
 SELECT indexrelid::regclass, indnatts, indnkeyatts, indisunique, indisprimary, indkey, indclass FROM pg_index WHERE indrelid = 'tbl'::regclass::oid;
  indexrelid | indnatts | indnkeyatts | indisunique | indisprimary | indkey  | indclass
 ------------+----------+-------------+-------------+--------------+---------+-----------
  covering   |        4 |           2 | t           | t            | 1 2 3 4 | 1978 1978
 (1 row)

 SELECT pg_get_constraintdef(oid), conname, conkey FROM pg_constraint WHERE conrelid = 'tbl'::regclass::oid;
          pg_get_constraintdef          | conname  | conkey
 ---------------------------------------+----------+--------
  PRIMARY KEY (c1, c2) INCLUDE (c3, c4) | covering | {1,2}
 (1 row)

 -- ensure that constraint works
 INSERT INTO tbl SELECT 1, 2, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
 ERROR:  duplicate key value violates unique constraint "covering"
 DETAIL:  Key (c1, c2)=(1, 2) already exists.
 INSERT INTO tbl SELECT 1, NULL, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
 ERROR:  null value in column "c2" of relation "tbl" violates not-null constraint
 DETAIL:  Failing row contains (1, null, 3, (4,4),(4,4)).
 INSERT INTO tbl SELECT x, 2*x, NULL, NULL FROM generate_series(1,300) AS x;
 -- GPDB: Dial down random_page_cost to get the same plan as in upstream.
 set random_page_cost=1.0;
 explain (costs off)
 select * from tbl where (c1,c2,c3) < (2,5,1);
                     QUERY PLAN
 --------------------------------------------------
  Gather Motion 3:1  (slice1; segments: 3)
    ->  Index Only Scan using covering on tbl
          Index Cond: (ROW(c1, c2) <= ROW(2, 5))
          Filter: (ROW(c1, c2, c3) < ROW(2, 5, 1))
  Optimizer: Postgres query optimizer
 (5 rows)

 select * from tbl where (c1,c2,c3) < (2,5,1);
  c1 | c2 | c3 | c4
 ----+----+----+----
   1 |  2 |    |
   2 |  4 |    |
 (2 rows)

 reset random_page_cost;
 -- row comparison that compares high key at page boundary
 SET enable_seqscan = off;
 explain (costs off)
 select * from tbl where (c1,c2,c3) < (262,1,1) order by 1 limit 1;
                            QUERY PLAN
 ----------------------------------------------------------------
  Limit
    ->  Gather Motion 3:1  (slice1; segments: 3)
          Merge Key: c1
          ->  Limit
                ->  Index Only Scan using covering on tbl
                      Index Cond: (ROW(c1, c2) <= ROW(262, 1))
                      Filter: (ROW(c1, c2, c3) < ROW(262, 1, 1))
  Optimizer: Postgres query optimizer
 (8 rows)

 select * from tbl where (c1,c2,c3) < (262,1,1) order by 1 limit 1;
  c1 | c2 | c3 | c4
 ----+----+----+----
   1 |  2 |    |
 (1 row)

 DROP TABLE tbl;
 RESET enable_seqscan;
 CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box,
 				UNIQUE(c1,c2) INCLUDE(c3,c4));
 SELECT indexrelid::regclass, indnatts, indnkeyatts, indisunique, indisprimary, indkey, indclass FROM pg_index WHERE indrelid = 'tbl'::regclass::oid;
      indexrelid      | indnatts | indnkeyatts | indisunique | indisprimary | indkey  | indclass
 ---------------------+----------+-------------+-------------+--------------+---------+-----------
  tbl_c1_c2_c3_c4_key |        4 |           2 | t           | f            | 1 2 3 4 | 1978 1978
 (1 row)

 SELECT pg_get_constraintdef(oid), conname, conkey FROM pg_constraint WHERE conrelid = 'tbl'::regclass::oid;
        pg_get_constraintdef       |       conname       | conkey
 ----------------------------------+---------------------+--------
  UNIQUE (c1, c2) INCLUDE (c3, c4) | tbl_c1_c2_c3_c4_key | {1,2}
 (1 row)

 -- ensure that constraint works
 INSERT INTO tbl SELECT 1, 2, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
 ERROR:  duplicate key value violates unique constraint "tbl_c1_c2_c3_c4_key"
 DETAIL:  Key (c1, c2)=(1, 2) already exists.
 DROP TABLE tbl;
 CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box,
 				PRIMARY KEY(c1,c2) INCLUDE(c3,c4));
 SELECT indexrelid::regclass, indnatts, indnkeyatts, indisunique, indisprimary, indkey, indclass FROM pg_index WHERE indrelid = 'tbl'::regclass::oid;
  indexrelid | indnatts | indnkeyatts | indisunique | indisprimary | indkey  | indclass
 ------------+----------+-------------+-------------+--------------+---------+-----------
  tbl_pkey   |        4 |           2 | t           | t            | 1 2 3 4 | 1978 1978
 (1 row)

 SELECT pg_get_constraintdef(oid), conname, conkey FROM pg_constraint WHERE conrelid = 'tbl'::regclass::oid;
          pg_get_constraintdef          | conname  | conkey
 ---------------------------------------+----------+--------
  PRIMARY KEY (c1, c2) INCLUDE (c3, c4) | tbl_pkey | {1,2}
 (1 row)

 -- ensure that constraint works
 INSERT INTO tbl SELECT 1, 2, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
 ERROR:  duplicate key value violates unique constraint "tbl_pkey"
 DETAIL:  Key (c1, c2)=(1, 2) already exists.
 INSERT INTO tbl SELECT 1, NULL, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
 ERROR:  null value in column "c2" of relation "tbl" violates not-null constraint
 DETAIL:  Failing row contains (1, null, 3, (4,4),(4,4)).
 INSERT INTO tbl SELECT x, 2*x, NULL, NULL FROM generate_series(1,10) AS x;
 DROP TABLE tbl;
 CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box,
 				EXCLUDE USING btree (c1 WITH =) INCLUDE(c3,c4));
 SELECT indexrelid::regclass, indnatts, indnkeyatts, indisunique, indisprimary, indkey, indclass FROM pg_index WHERE indrelid = 'tbl'::regclass::oid;
     indexrelid     | indnatts | indnkeyatts | indisunique | indisprimary | indkey | indclass
 -------------------+----------+-------------+-------------+--------------+--------+----------
  tbl_c1_c3_c4_excl |        3 |           1 | f           | f            | 1 3 4  | 1978
 (1 row)

 SELECT pg_get_constraintdef(oid), conname, conkey FROM pg_constraint WHERE conrelid = 'tbl'::regclass::oid;
                pg_get_constraintdef               |      conname      | conkey
 --------------------------------------------------+-------------------+--------
  EXCLUDE USING btree (c1 WITH =) INCLUDE (c3, c4) | tbl_c1_c3_c4_excl | {1}
 (1 row)

 -- ensure that constraint works
 INSERT INTO tbl SELECT 1, 2, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
 ERROR:  conflicting key value violates exclusion constraint "tbl_c1_c3_c4_excl"
 DETAIL:  Key (c1)=(1) conflicts with existing key (c1)=(1).
 INSERT INTO tbl SELECT x, 2*x, NULL, NULL FROM generate_series(1,10) AS x;
 DROP TABLE tbl;
 /*
  * 3.0 Test ALTER TABLE DROP COLUMN.
  * Any column deletion leads to index deletion.
  */
 CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 int);
 CREATE UNIQUE INDEX tbl_idx ON tbl using btree(c1, c2, c3, c4);
 SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
                                 indexdef
 ------------------------------------------------------------------------
  CREATE UNIQUE INDEX tbl_idx ON public.tbl USING btree (c1, c2, c3, c4)
 (1 row)

 ALTER TABLE tbl DROP COLUMN c3;
 SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
  indexdef
 ----------
 (0 rows)

 DROP TABLE tbl;
 /*
  * 3.1 Test ALTER TABLE DROP COLUMN.
  * Included column deletion leads to the index deletion,
  * AS well AS key columns deletion. It's explained in documentation.
  */
 CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box);
 CREATE UNIQUE INDEX tbl_idx ON tbl using btree(c1, c2) INCLUDE(c3,c4);
 SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
                                     indexdef
 ---------------------------------------------------------------------------------
  CREATE UNIQUE INDEX tbl_idx ON public.tbl USING btree (c1, c2) INCLUDE (c3, c4)
 (1 row)

 ALTER TABLE tbl DROP COLUMN c3;
 SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
  indexdef
 ----------
 (0 rows)

 DROP TABLE tbl;
 /*
  * 3.2 Test ALTER TABLE DROP COLUMN.
  * Included column deletion leads to the index deletion.
  * AS well AS key columns deletion. It's explained in documentation.
  */
 CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box, UNIQUE(c1, c2) INCLUDE(c3,c4));
 SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
                                           indexdef
 ---------------------------------------------------------------------------------------------
  CREATE UNIQUE INDEX tbl_c1_c2_c3_c4_key ON public.tbl USING btree (c1, c2) INCLUDE (c3, c4)
 (1 row)

 ALTER TABLE tbl DROP COLUMN c3;
 SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
  indexdef
 ----------
 (0 rows)

 ALTER TABLE tbl DROP COLUMN c1;
 SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
  indexdef
 ----------
 (0 rows)

 DROP TABLE tbl;
 /*
  * 3.3 Test ALTER TABLE SET STATISTICS
  */
 CREATE TABLE tbl (c1 int, c2 int);
 CREATE INDEX tbl_idx ON tbl (c1, (c1+0)) INCLUDE (c2);
 ALTER INDEX tbl_idx ALTER COLUMN 1 SET STATISTICS 1000;
 ERROR:  cannot alter statistics on non-expression column "c1" of index "tbl_idx"
 HINT:  Alter statistics on table column instead.
 ALTER INDEX tbl_idx ALTER COLUMN 2 SET STATISTICS 1000;
 ALTER INDEX tbl_idx ALTER COLUMN 3 SET STATISTICS 1000;
 ERROR:  cannot alter statistics on included column "c2" of index "tbl_idx"
 ALTER INDEX tbl_idx ALTER COLUMN 4 SET STATISTICS 1000;
 ERROR:  column number 4 of relation "tbl_idx" does not exist
 DROP TABLE tbl;
 /*
  * 4. CREATE INDEX CONCURRENTLY
  */
 CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box, UNIQUE(c1, c2) INCLUDE(c3,c4));
 INSERT INTO tbl SELECT x, 2*x, 3*x, box('4,4,4,4') FROM generate_series(1,1000) AS x;
 CREATE UNIQUE INDEX CONCURRENTLY on tbl (c1, c2) INCLUDE (c3, c4);
 SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
                                           indexdef
 ---------------------------------------------------------------------------------------------
  CREATE UNIQUE INDEX tbl_c1_c2_c3_c4_idx ON public.tbl USING btree (c1, c2) INCLUDE (c3, c4)
  CREATE UNIQUE INDEX tbl_c1_c2_c3_c4_key ON public.tbl USING btree (c1, c2) INCLUDE (c3, c4)
 (2 rows)

 DROP TABLE tbl;
 /*
  * 5. REINDEX
  */
 CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box, UNIQUE(c1, c2) INCLUDE(c3,c4));
 SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
                                           indexdef
 ---------------------------------------------------------------------------------------------
  CREATE UNIQUE INDEX tbl_c1_c2_c3_c4_key ON public.tbl USING btree (c1, c2) INCLUDE (c3, c4)
 (1 row)

 ALTER TABLE tbl DROP COLUMN c3;
 SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
  indexdef
 ----------
 (0 rows)

 REINDEX INDEX tbl_c1_c2_c3_c4_key;
 ERROR:  relation "tbl_c1_c2_c3_c4_key" does not exist
 SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
  indexdef
 ----------
 (0 rows)

 ALTER TABLE tbl DROP COLUMN c1;
 SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
  indexdef
 ----------
 (0 rows)

 DROP TABLE tbl;
 /*
  * 7. Check various AMs. All but btree, gist and spgist must fail.
  */
 CREATE TABLE tbl (c1 int,c2 int, c3 box, c4 box);
 CREATE INDEX on tbl USING brin(c1, c2) INCLUDE (c3, c4);
 ERROR:  access method "brin" does not support included columns
 CREATE INDEX on tbl USING gist(c3) INCLUDE (c1, c4);
 CREATE INDEX on tbl USING spgist(c3) INCLUDE (c4);
 CREATE INDEX on tbl USING gin(c1, c2) INCLUDE (c3, c4);
 ERROR:  access method "gin" does not support included columns
 CREATE INDEX on tbl USING hash(c1, c2) INCLUDE (c3, c4);
 ERROR:  access method "hash" does not support included columns
 CREATE INDEX on tbl USING rtree(c3) INCLUDE (c1, c4);
 NOTICE:  substituting access method "gist" for obsolete method "rtree"
 CREATE INDEX on tbl USING btree(c1, c2) INCLUDE (c3, c4);
 DROP TABLE tbl;
 /*
  * 8. Update, delete values in indexed table.
  */
 CREATE TABLE tbl (c1 int, c2 int, c3 int, c4 box);
 INSERT INTO tbl SELECT x, 2*x, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
 CREATE UNIQUE INDEX tbl_idx_unique ON tbl using btree(c1, c2) INCLUDE (c3,c4);
 UPDATE tbl SET c1 = 100 WHERE c1 = 2;
 UPDATE tbl SET c1 = 1 WHERE c1 = 3;
 -- should fail
 UPDATE tbl SET c2 = 2 WHERE c1 = 1;
 ERROR:  duplicate key value violates unique constraint "tbl_idx_unique"
 DETAIL:  Key (c1, c2)=(1, 2) already exists.
 UPDATE tbl SET c3 = 1;
 DELETE FROM tbl WHERE c1 = 5 OR c3 = 12;
 DROP TABLE tbl;
 /*
  * 9. Alter column type.
  */
 CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box, UNIQUE(c1, c2) INCLUDE(c3,c4));
 INSERT INTO tbl SELECT x, 2*x, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
 ALTER TABLE tbl ALTER c1 TYPE bigint;
 ERROR:  cannot alter column with primary key or unique constraint
 HINT:  DROP the constraint first, and recreate it after the ALTER
 ALTER TABLE tbl ALTER c3 TYPE bigint;
 ERROR:  cannot alter column with primary key or unique constraint
 HINT:  DROP the constraint first, and recreate it after the ALTER
 \d tbl
                 Table "public.tbl"
  Column |  Type   | Collation | Nullable | Default
 --------+---------+-----------+----------+---------
  c1     | integer |           |          |
  c2     | integer |           |          |
  c3     | integer |           |          |
  c4     | box     |           |          |
 Indexes:
     "tbl_c1_c2_c3_c4_key" UNIQUE CONSTRAINT, btree (c1, c2) INCLUDE (c3, c4)

 DROP TABLE tbl;
 /*
  * 10. Test coverage for names stored as cstrings in indexes
  */
 CREATE TABLE nametbl (c1 int, c2 name, c3 float);
 CREATE INDEX nametbl_c1_c2_idx ON nametbl (c2, c1) INCLUDE (c3);
 INSERT INTO nametbl  SELECT x, 'two', 3.0 FROM generate_series(1,100) AS x;;
 VACUUM FREEZE nametbl;
 ANALYZE nametbl;
 SET enable_seqscan = 0;
 -- Ensure we get an index only scan plan
 EXPLAIN (COSTS OFF) SELECT c2, c1, c3 FROM nametbl WHERE c2 = 'two' AND c1 = 1;
                         QUERY PLAN
 ----------------------------------------------------------
  Gather Motion 1:1  (slice1; segments: 1)
    ->  Index Only Scan using nametbl_c1_c2_idx on nametbl
          Index Cond: ((c2 = 'two'::name) AND (c1 = 1))
  Optimizer: GPORCA
 (4 rows)

 -- Validate the results look sane
 SELECT c2, c1, c3 FROM nametbl WHERE c2 = 'two' AND c1 = 1;
  c2  | c1 | c3
 -----+----+----
  two |  1 |  3
 (1 row)

 RESET enable_seqscan;
 DROP TABLE nametbl;
	/*
	* 1.test CREATE INDEX
	*
	* Deliberately avoid dropping objects in this section, to get some pg_dump
	* coverage.
	*/
	-- Regular index with included columns
	CREATE TABLE tbl_include_reg (c1 int, c2 int, c3 int, c4 box);
	INSERT INTO tbl_include_reg SELECT x, 2x, 3x, box('4,4,4,4') FROM generate_series(1,10) AS x;
	CREATE INDEX tbl_include_reg_idx ON tbl_include_reg (c1, c2) INCLUDE (c3, c4);
	-- duplicate column is pretty pointless, but we allow it anyway
	CREATE INDEX ON tbl_include_reg (c1, c2) INCLUDE (c1, c3);
	SELECT pg_get_indexdef(i.indexrelid)
	FROM pg_index i JOIN pg_class c ON i.indexrelid = c.oid
	WHERE i.indrelid = 'tbl_include_reg'::regclass ORDER BY c.relname;
	pg_get_indexdef
	---------------------------------------------------------------------------------------------------------------
	CREATE INDEX tbl_include_reg_c1_c2_c11_c3_idx ON public.tbl_include_reg USING btree (c1, c2) INCLUDE (c1, c3)
	CREATE INDEX tbl_include_reg_idx ON public.tbl_include_reg USING btree (c1, c2) INCLUDE (c3, c4)
	(2 rows)

	\d tbl_include_reg_idx
	Index "public.tbl_include_reg_idx"
	Column \| Type \| Key? \| Definition
	--------+---------+------+------------
	c1 \| integer \| yes \| c1
	c2 \| integer \| yes \| c2
	c3 \| integer \| no \| c3
	c4 \| box \| no \| c4
	btree, for table "public.tbl_include_reg"

	-- Unique index and unique constraint
	CREATE TABLE tbl_include_unique1 (c1 int, c2 int, c3 int, c4 box);
	INSERT INTO tbl_include_unique1 SELECT x, 2x, 3x, box('4,4,4,4') FROM generate_series(1,10) AS x;
	CREATE UNIQUE INDEX tbl_include_unique1_idx_unique ON tbl_include_unique1 using btree (c1, c2) INCLUDE (c3, c4);
	ALTER TABLE tbl_include_unique1 add UNIQUE USING INDEX tbl_include_unique1_idx_unique;
	ALTER TABLE tbl_include_unique1 add UNIQUE (c1, c2) INCLUDE (c3, c4);
	SELECT pg_get_indexdef(i.indexrelid)
	FROM pg_index i JOIN pg_class c ON i.indexrelid = c.oid
	WHERE i.indrelid = 'tbl_include_unique1'::regclass ORDER BY c.relname;
	pg_get_indexdef
	-----------------------------------------------------------------------------------------------------------------------------
	CREATE UNIQUE INDEX tbl_include_unique1_c1_c2_c3_c4_key ON public.tbl_include_unique1 USING btree (c1, c2) INCLUDE (c3, c4)
	CREATE UNIQUE INDEX tbl_include_unique1_idx_unique ON public.tbl_include_unique1 USING btree (c1, c2) INCLUDE (c3, c4)
	(2 rows)

	-- Unique index and unique constraint. Both must fail.
	CREATE TABLE tbl_include_unique2 (c1 int, c2 int, c3 int, c4 box);
	INSERT INTO tbl_include_unique2 SELECT 1, 2, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
	CREATE UNIQUE INDEX tbl_include_unique2_idx_unique ON tbl_include_unique2 using btree (c1, c2) INCLUDE (c3, c4);
	ERROR: could not create unique index "tbl_include_unique2_idx_unique"
	DETAIL: Key (c1, c2)=(1, 2) is duplicated.
	ALTER TABLE tbl_include_unique2 add UNIQUE (c1, c2) INCLUDE (c3, c4);
	ERROR: could not create unique index "tbl_include_unique2_c1_c2_c3_c4_key"
	DETAIL: Key (c1, c2)=(1, 2) is duplicated.
	-- PK constraint
	CREATE TABLE tbl_include_pk (c1 int, c2 int, c3 int, c4 box);
	INSERT INTO tbl_include_pk SELECT 1, 2x, 3x, box('4,4,4,4') FROM generate_series(1,10) AS x;
	ALTER TABLE tbl_include_pk add PRIMARY KEY (c1, c2) INCLUDE (c3, c4);
	SELECT pg_get_indexdef(i.indexrelid)
	FROM pg_index i JOIN pg_class c ON i.indexrelid = c.oid
	WHERE i.indrelid = 'tbl_include_pk'::regclass ORDER BY c.relname;
	pg_get_indexdef
	--------------------------------------------------------------------------------------------------------
	CREATE UNIQUE INDEX tbl_include_pk_pkey ON public.tbl_include_pk USING btree (c1, c2) INCLUDE (c3, c4)
	(1 row)

	CREATE TABLE tbl_include_box (c1 int, c2 int, c3 int, c4 box);
	INSERT INTO tbl_include_box SELECT 1, 2x, 3x, box('4,4,4,4') FROM generate_series(1,10) AS x;
	CREATE UNIQUE INDEX tbl_include_box_idx_unique ON tbl_include_box using btree (c1, c2) INCLUDE (c3, c4);
	ALTER TABLE tbl_include_box add PRIMARY KEY USING INDEX tbl_include_box_idx_unique;
	SELECT pg_get_indexdef(i.indexrelid)
	FROM pg_index i JOIN pg_class c ON i.indexrelid = c.oid
	WHERE i.indrelid = 'tbl_include_box'::regclass ORDER BY c.relname;
	pg_get_indexdef
	----------------------------------------------------------------------------------------------------------------
	CREATE UNIQUE INDEX tbl_include_box_idx_unique ON public.tbl_include_box USING btree (c1, c2) INCLUDE (c3, c4)
	(1 row)

	-- PK constraint. Must fail.
	CREATE TABLE tbl_include_box_pk (c1 int, c2 int, c3 int, c4 box);
	INSERT INTO tbl_include_box_pk SELECT 1, 2, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
	ALTER TABLE tbl_include_box_pk add PRIMARY KEY (c1, c2) INCLUDE (c3, c4);
	ERROR: could not create unique index "tbl_include_box_pk_pkey"
	DETAIL: Key (c1, c2)=(1, 2) is duplicated.
	/*
	* 2. Test CREATE TABLE with constraint
	*/
	CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box,
	CONSTRAINT covering UNIQUE(c1,c2) INCLUDE(c3,c4));
	SELECT indexrelid::regclass, indnatts, indnkeyatts, indisunique, indisprimary, indkey, indclass FROM pg_index WHERE indrelid = 'tbl'::regclass::oid;
	indexrelid \| indnatts \| indnkeyatts \| indisunique \| indisprimary \| indkey \| indclass
	------------+----------+-------------+-------------+--------------+---------+-----------
	covering \| 4 \| 2 \| t \| f \| 1 2 3 4 \| 1978 1978
	(1 row)

	SELECT pg_get_constraintdef(oid), conname, conkey FROM pg_constraint WHERE conrelid = 'tbl'::regclass::oid;
	pg_get_constraintdef \| conname \| conkey
	----------------------------------+----------+--------
	UNIQUE (c1, c2) INCLUDE (c3, c4) \| covering \| {1,2}
	(1 row)

	-- ensure that constraint works
	INSERT INTO tbl SELECT 1, 2, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
	ERROR: duplicate key value violates unique constraint "covering"
	DETAIL: Key (c1, c2)=(1, 2) already exists.
	DROP TABLE tbl;
	CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box,
	CONSTRAINT covering PRIMARY KEY(c1,c2) INCLUDE(c3,c4));
	SELECT indexrelid::regclass, indnatts, indnkeyatts, indisunique, indisprimary, indkey, indclass FROM pg_index WHERE indrelid = 'tbl'::regclass::oid;
	indexrelid \| indnatts \| indnkeyatts \| indisunique \| indisprimary \| indkey \| indclass
	------------+----------+-------------+-------------+--------------+---------+-----------
	covering \| 4 \| 2 \| t \| t \| 1 2 3 4 \| 1978 1978
	(1 row)

	SELECT pg_get_constraintdef(oid), conname, conkey FROM pg_constraint WHERE conrelid = 'tbl'::regclass::oid;
	pg_get_constraintdef \| conname \| conkey
	---------------------------------------+----------+--------
	PRIMARY KEY (c1, c2) INCLUDE (c3, c4) \| covering \| {1,2}
	(1 row)

	-- ensure that constraint works
	INSERT INTO tbl SELECT 1, 2, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
	ERROR: duplicate key value violates unique constraint "covering"
	DETAIL: Key (c1, c2)=(1, 2) already exists.
	INSERT INTO tbl SELECT 1, NULL, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
	ERROR: null value in column "c2" of relation "tbl" violates not-null constraint
	DETAIL: Failing row contains (1, null, 3, (4,4),(4,4)).
	INSERT INTO tbl SELECT x, 2*x, NULL, NULL FROM generate_series(1,300) AS x;
	-- GPDB: Dial down random_page_cost to get the same plan as in upstream.
	set random_page_cost=1.0;
	explain (costs off)
	select * from tbl where (c1,c2,c3) < (2,5,1);
	QUERY PLAN
	--------------------------------------------------
	Gather Motion 3:1 (slice1; segments: 3)
	-> Index Only Scan using covering on tbl
	Index Cond: (ROW(c1, c2) <= ROW(2, 5))
	Filter: (ROW(c1, c2, c3) < ROW(2, 5, 1))
	Optimizer: Postgres query optimizer
	(5 rows)

	select * from tbl where (c1,c2,c3) < (2,5,1);
	c1 \| c2 \| c3 \| c4
	----+----+----+----
	1 \| 2 \| \|
	2 \| 4 \| \|
	(2 rows)

	reset random_page_cost;
	-- row comparison that compares high key at page boundary
	SET enable_seqscan = off;
	explain (costs off)
	select * from tbl where (c1,c2,c3) < (262,1,1) order by 1 limit 1;
	QUERY PLAN
	----------------------------------------------------------------
	Limit
	-> Gather Motion 3:1 (slice1; segments: 3)
	Merge Key: c1
	-> Limit
	-> Index Only Scan using covering on tbl
	Index Cond: (ROW(c1, c2) <= ROW(262, 1))
	Filter: (ROW(c1, c2, c3) < ROW(262, 1, 1))
	Optimizer: Postgres query optimizer
	(8 rows)

	select * from tbl where (c1,c2,c3) < (262,1,1) order by 1 limit 1;
	c1 \| c2 \| c3 \| c4
	----+----+----+----
	1 \| 2 \| \|
	(1 row)

	DROP TABLE tbl;
	RESET enable_seqscan;
	CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box,
	UNIQUE(c1,c2) INCLUDE(c3,c4));
	SELECT indexrelid::regclass, indnatts, indnkeyatts, indisunique, indisprimary, indkey, indclass FROM pg_index WHERE indrelid = 'tbl'::regclass::oid;
	indexrelid \| indnatts \| indnkeyatts \| indisunique \| indisprimary \| indkey \| indclass
	---------------------+----------+-------------+-------------+--------------+---------+-----------
	tbl_c1_c2_c3_c4_key \| 4 \| 2 \| t \| f \| 1 2 3 4 \| 1978 1978
	(1 row)

	SELECT pg_get_constraintdef(oid), conname, conkey FROM pg_constraint WHERE conrelid = 'tbl'::regclass::oid;
	pg_get_constraintdef \| conname \| conkey
	----------------------------------+---------------------+--------
	UNIQUE (c1, c2) INCLUDE (c3, c4) \| tbl_c1_c2_c3_c4_key \| {1,2}
	(1 row)

	-- ensure that constraint works
	INSERT INTO tbl SELECT 1, 2, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
	ERROR: duplicate key value violates unique constraint "tbl_c1_c2_c3_c4_key"
	DETAIL: Key (c1, c2)=(1, 2) already exists.
	DROP TABLE tbl;
	CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box,
	PRIMARY KEY(c1,c2) INCLUDE(c3,c4));
	SELECT indexrelid::regclass, indnatts, indnkeyatts, indisunique, indisprimary, indkey, indclass FROM pg_index WHERE indrelid = 'tbl'::regclass::oid;
	indexrelid \| indnatts \| indnkeyatts \| indisunique \| indisprimary \| indkey \| indclass
	------------+----------+-------------+-------------+--------------+---------+-----------
	tbl_pkey \| 4 \| 2 \| t \| t \| 1 2 3 4 \| 1978 1978
	(1 row)

	SELECT pg_get_constraintdef(oid), conname, conkey FROM pg_constraint WHERE conrelid = 'tbl'::regclass::oid;
	pg_get_constraintdef \| conname \| conkey
	---------------------------------------+----------+--------
	PRIMARY KEY (c1, c2) INCLUDE (c3, c4) \| tbl_pkey \| {1,2}
	(1 row)

	-- ensure that constraint works
	INSERT INTO tbl SELECT 1, 2, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
	ERROR: duplicate key value violates unique constraint "tbl_pkey"
	DETAIL: Key (c1, c2)=(1, 2) already exists.
	INSERT INTO tbl SELECT 1, NULL, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
	ERROR: null value in column "c2" of relation "tbl" violates not-null constraint
	DETAIL: Failing row contains (1, null, 3, (4,4),(4,4)).
	INSERT INTO tbl SELECT x, 2*x, NULL, NULL FROM generate_series(1,10) AS x;
	DROP TABLE tbl;
	CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box,
	EXCLUDE USING btree (c1 WITH =) INCLUDE(c3,c4));
	SELECT indexrelid::regclass, indnatts, indnkeyatts, indisunique, indisprimary, indkey, indclass FROM pg_index WHERE indrelid = 'tbl'::regclass::oid;
	indexrelid \| indnatts \| indnkeyatts \| indisunique \| indisprimary \| indkey \| indclass
	-------------------+----------+-------------+-------------+--------------+--------+----------
	tbl_c1_c3_c4_excl \| 3 \| 1 \| f \| f \| 1 3 4 \| 1978
	(1 row)

	SELECT pg_get_constraintdef(oid), conname, conkey FROM pg_constraint WHERE conrelid = 'tbl'::regclass::oid;
	pg_get_constraintdef \| conname \| conkey
	--------------------------------------------------+-------------------+--------
	EXCLUDE USING btree (c1 WITH =) INCLUDE (c3, c4) \| tbl_c1_c3_c4_excl \| {1}
	(1 row)

	-- ensure that constraint works
	INSERT INTO tbl SELECT 1, 2, 3*x, box('4,4,4,4') FROM generate_series(1,10) AS x;
	ERROR: conflicting key value violates exclusion constraint "tbl_c1_c3_c4_excl"
	DETAIL: Key (c1)=(1) conflicts with existing key (c1)=(1).
	INSERT INTO tbl SELECT x, 2*x, NULL, NULL FROM generate_series(1,10) AS x;
	DROP TABLE tbl;
	/*
	* 3.0 Test ALTER TABLE DROP COLUMN.
	* Any column deletion leads to index deletion.
	*/
	CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 int);
	CREATE UNIQUE INDEX tbl_idx ON tbl using btree(c1, c2, c3, c4);
	SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
	indexdef
	------------------------------------------------------------------------
	CREATE UNIQUE INDEX tbl_idx ON public.tbl USING btree (c1, c2, c3, c4)
	(1 row)

	ALTER TABLE tbl DROP COLUMN c3;
	SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
	indexdef
	----------
	(0 rows)

	DROP TABLE tbl;
	/*
	* 3.1 Test ALTER TABLE DROP COLUMN.
	* Included column deletion leads to the index deletion,
	* AS well AS key columns deletion. It's explained in documentation.
	*/
	CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box);
	CREATE UNIQUE INDEX tbl_idx ON tbl using btree(c1, c2) INCLUDE(c3,c4);
	SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
	indexdef
	---------------------------------------------------------------------------------
	CREATE UNIQUE INDEX tbl_idx ON public.tbl USING btree (c1, c2) INCLUDE (c3, c4)
	(1 row)

	ALTER TABLE tbl DROP COLUMN c3;
	SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
	indexdef
	----------
	(0 rows)

	DROP TABLE tbl;
	/*
	* 3.2 Test ALTER TABLE DROP COLUMN.
	* Included column deletion leads to the index deletion.
	* AS well AS key columns deletion. It's explained in documentation.
	*/
	CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box, UNIQUE(c1, c2) INCLUDE(c3,c4));
	SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
	indexdef
	---------------------------------------------------------------------------------------------
	CREATE UNIQUE INDEX tbl_c1_c2_c3_c4_key ON public.tbl USING btree (c1, c2) INCLUDE (c3, c4)
	(1 row)

	ALTER TABLE tbl DROP COLUMN c3;
	SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
	indexdef
	----------
	(0 rows)

	ALTER TABLE tbl DROP COLUMN c1;
	SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
	indexdef
	----------
	(0 rows)

	DROP TABLE tbl;
	/*
	* 3.3 Test ALTER TABLE SET STATISTICS
	*/
	CREATE TABLE tbl (c1 int, c2 int);
	CREATE INDEX tbl_idx ON tbl (c1, (c1+0)) INCLUDE (c2);
	ALTER INDEX tbl_idx ALTER COLUMN 1 SET STATISTICS 1000;
	ERROR: cannot alter statistics on non-expression column "c1" of index "tbl_idx"
	HINT: Alter statistics on table column instead.
	ALTER INDEX tbl_idx ALTER COLUMN 2 SET STATISTICS 1000;
	ALTER INDEX tbl_idx ALTER COLUMN 3 SET STATISTICS 1000;
	ERROR: cannot alter statistics on included column "c2" of index "tbl_idx"
	ALTER INDEX tbl_idx ALTER COLUMN 4 SET STATISTICS 1000;
	ERROR: column number 4 of relation "tbl_idx" does not exist
	DROP TABLE tbl;
	/*
	* 4. CREATE INDEX CONCURRENTLY
	*/
	CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box, UNIQUE(c1, c2) INCLUDE(c3,c4));
	INSERT INTO tbl SELECT x, 2x, 3x, box('4,4,4,4') FROM generate_series(1,1000) AS x;
	CREATE UNIQUE INDEX CONCURRENTLY on tbl (c1, c2) INCLUDE (c3, c4);
	SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
	indexdef
	---------------------------------------------------------------------------------------------
	CREATE UNIQUE INDEX tbl_c1_c2_c3_c4_idx ON public.tbl USING btree (c1, c2) INCLUDE (c3, c4)
	CREATE UNIQUE INDEX tbl_c1_c2_c3_c4_key ON public.tbl USING btree (c1, c2) INCLUDE (c3, c4)
	(2 rows)

	DROP TABLE tbl;
	/*
	* 5. REINDEX
	*/
	CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box, UNIQUE(c1, c2) INCLUDE(c3,c4));
	SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
	indexdef
	---------------------------------------------------------------------------------------------
	CREATE UNIQUE INDEX tbl_c1_c2_c3_c4_key ON public.tbl USING btree (c1, c2) INCLUDE (c3, c4)
	(1 row)

	ALTER TABLE tbl DROP COLUMN c3;
	SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
	indexdef
	----------
	(0 rows)

	REINDEX INDEX tbl_c1_c2_c3_c4_key;
	ERROR: relation "tbl_c1_c2_c3_c4_key" does not exist
	SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
	indexdef
	----------
	(0 rows)

	ALTER TABLE tbl DROP COLUMN c1;
	SELECT indexdef FROM pg_indexes WHERE tablename = 'tbl' ORDER BY indexname;
	indexdef
	----------
	(0 rows)

	DROP TABLE tbl;
	/*
	* 7. Check various AMs. All but btree, gist and spgist must fail.
	*/
	CREATE TABLE tbl (c1 int,c2 int, c3 box, c4 box);
	CREATE INDEX on tbl USING brin(c1, c2) INCLUDE (c3, c4);
	ERROR: access method "brin" does not support included columns
	CREATE INDEX on tbl USING gist(c3) INCLUDE (c1, c4);
	CREATE INDEX on tbl USING spgist(c3) INCLUDE (c4);
	CREATE INDEX on tbl USING gin(c1, c2) INCLUDE (c3, c4);
	ERROR: access method "gin" does not support included columns
	CREATE INDEX on tbl USING hash(c1, c2) INCLUDE (c3, c4);
	ERROR: access method "hash" does not support included columns
	CREATE INDEX on tbl USING rtree(c3) INCLUDE (c1, c4);
	NOTICE: substituting access method "gist" for obsolete method "rtree"
	CREATE INDEX on tbl USING btree(c1, c2) INCLUDE (c3, c4);
	DROP TABLE tbl;
	/*
	* 8. Update, delete values in indexed table.
	*/
	CREATE TABLE tbl (c1 int, c2 int, c3 int, c4 box);
	INSERT INTO tbl SELECT x, 2x, 3x, box('4,4,4,4') FROM generate_series(1,10) AS x;
	CREATE UNIQUE INDEX tbl_idx_unique ON tbl using btree(c1, c2) INCLUDE (c3,c4);
	UPDATE tbl SET c1 = 100 WHERE c1 = 2;
	UPDATE tbl SET c1 = 1 WHERE c1 = 3;
	-- should fail
	UPDATE tbl SET c2 = 2 WHERE c1 = 1;
	ERROR: duplicate key value violates unique constraint "tbl_idx_unique"
	DETAIL: Key (c1, c2)=(1, 2) already exists.
	UPDATE tbl SET c3 = 1;
	DELETE FROM tbl WHERE c1 = 5 OR c3 = 12;
	DROP TABLE tbl;
	/*
	* 9. Alter column type.
	*/
	CREATE TABLE tbl (c1 int,c2 int, c3 int, c4 box, UNIQUE(c1, c2) INCLUDE(c3,c4));
	INSERT INTO tbl SELECT x, 2x, 3x, box('4,4,4,4') FROM generate_series(1,10) AS x;
	ALTER TABLE tbl ALTER c1 TYPE bigint;
	ERROR: cannot alter column with primary key or unique constraint
	HINT: DROP the constraint first, and recreate it after the ALTER
	ALTER TABLE tbl ALTER c3 TYPE bigint;
	ERROR: cannot alter column with primary key or unique constraint
	HINT: DROP the constraint first, and recreate it after the ALTER
	\d tbl
	Table "public.tbl"
	Column \| Type \| Collation \| Nullable \| Default
	--------+---------+-----------+----------+---------
	c1 \| integer \| \| \|
	c2 \| integer \| \| \|
	c3 \| integer \| \| \|
	c4 \| box \| \| \|
	Indexes:
	"tbl_c1_c2_c3_c4_key" UNIQUE CONSTRAINT, btree (c1, c2) INCLUDE (c3, c4)

	DROP TABLE tbl;
	/*
	* 10. Test coverage for names stored as cstrings in indexes
	*/
	CREATE TABLE nametbl (c1 int, c2 name, c3 float);
	CREATE INDEX nametbl_c1_c2_idx ON nametbl (c2, c1) INCLUDE (c3);
	INSERT INTO nametbl SELECT x, 'two', 3.0 FROM generate_series(1,100) AS x;;
	VACUUM FREEZE nametbl;
	ANALYZE nametbl;
	SET enable_seqscan = 0;
	-- Ensure we get an index only scan plan
	EXPLAIN (COSTS OFF) SELECT c2, c1, c3 FROM nametbl WHERE c2 = 'two' AND c1 = 1;
	QUERY PLAN
	----------------------------------------------------------
	Gather Motion 1:1 (slice1; segments: 1)
	-> Index Only Scan using nametbl_c1_c2_idx on nametbl
	Index Cond: ((c2 = 'two'::name) AND (c1 = 1))
	Optimizer: GPORCA
	(4 rows)

	-- Validate the results look sane
	SELECT c2, c1, c3 FROM nametbl WHERE c2 = 'two' AND c1 = 1;
	c2 \| c1 \| c3
	-----+----+----
	two \| 1 \| 3
	(1 row)

	RESET enable_seqscan;
	DROP TABLE nametbl;