Columnar: tighten security and improve visibility. (#5922)

Move internal storage details to a separate schema with no public
access to limit the possibility for information leakage.

Create views with public access that show storage details for those
columnar tables where the user has ownership privileges. Include
mapping between relation ID and storage ID for easier interpretation.

src/backend/columnar/columnar_metadata.c

@@ -1820,7 +1820,15 @@ ColumnarChunkGroupIndexRelationId(void)
 static Oid
 ColumnarNamespaceId(void)
 {
-	return get_namespace_oid("columnar", false);
+	Oid namespace = get_namespace_oid("columnar_internal", true);
+
+	/* if schema is earlier than 11.1-1 */
+	if (!OidIsValid(namespace))
+	{
+		namespace = get_namespace_oid("columnar", false);
+	}
+
+	return namespace;
 }
 
 
@@ -1862,6 +1870,13 @@ columnar_relation_storageid(PG_FUNCTION_ARGS)
 {
 	Oid relationId = PG_GETARG_OID(0);
 	Relation relation = relation_open(relationId, AccessShareLock);
+
+	if (!pg_class_ownercheck(relationId, GetUserId()))
+	{
+		aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_TABLE,
+					   get_rel_name(relationId));
+	}
+
 	if (!IsColumnarTableAmTable(relationId))
 	{
 		elog(ERROR, "relation \"%s\" is not a columnar table",

src/backend/columnar/sql/columnar--11.0-2--11.1-1.sql

@@ -1,2 +1,71 @@
 #include "udfs/alter_columnar_table_set/11.1-1.sql"
 #include "udfs/alter_columnar_table_reset/11.1-1.sql"
+
+-- rename columnar schema to columnar_internal and tighten security
+
+REVOKE ALL PRIVILEGES ON ALL TABLES IN SCHEMA columnar FROM PUBLIC;
+ALTER SCHEMA columnar RENAME TO columnar_internal;
+REVOKE ALL PRIVILEGES ON SCHEMA columnar_internal FROM PUBLIC;
+
+-- create columnar schema with public usage privileges
+
+CREATE SCHEMA columnar;
+GRANT USAGE ON SCHEMA columnar TO PUBLIC;
+
+-- update UDF to account for columnar_internal schema
+#include "udfs/columnar_ensure_am_depends_catalog/11.1-1.sql"
+
+-- add utility function
+
+CREATE FUNCTION columnar.get_storage_id(regclass) RETURNS bigint
+    LANGUAGE C STRICT
+    AS 'citus_columnar', $$columnar_relation_storageid$$;
+
+-- create views for columnar table information
+
+CREATE VIEW columnar.storage WITH (security_barrier) AS
+  SELECT c.oid::regclass AS relation,
+         columnar.get_storage_id(c.oid) AS storage_id
+    FROM pg_class c, pg_am am
+    WHERE c.relam = am.oid AND am.amname = 'columnar'
+      AND pg_has_role(c.relowner, 'USAGE');
+COMMENT ON VIEW columnar.storage IS 'Columnar relation ID to storage ID mapping.';
+GRANT SELECT ON columnar.storage TO PUBLIC;
+
+CREATE VIEW columnar.options WITH (security_barrier) AS
+  SELECT regclass AS relation, chunk_group_row_limit,
+         stripe_row_limit, compression, compression_level
+    FROM columnar_internal.options o, pg_class c
+    WHERE o.regclass = c.oid
+      AND pg_has_role(c.relowner, 'USAGE');
+COMMENT ON VIEW columnar.options
+  IS 'Columnar options for tables on which the current user has ownership privileges.';
+GRANT SELECT ON columnar.options TO PUBLIC;
+
+CREATE VIEW columnar.stripe WITH (security_barrier) AS
+  SELECT relation, storage.storage_id, stripe_num, file_offset, data_length,
+         column_count, chunk_row_count, row_count, chunk_group_count, first_row_number
+    FROM columnar_internal.stripe stripe, columnar.storage storage
+    WHERE stripe.storage_id = storage.storage_id;
+COMMENT ON VIEW columnar.stripe
+  IS 'Columnar stripe information for tables on which the current user has ownership privileges.';
+GRANT SELECT ON columnar.stripe TO PUBLIC;
+
+CREATE VIEW columnar.chunk_group WITH (security_barrier) AS
+  SELECT relation, storage.storage_id, stripe_num, chunk_group_num, row_count
+    FROM columnar_internal.chunk_group cg, columnar.storage storage
+    WHERE cg.storage_id = storage.storage_id;
+COMMENT ON VIEW columnar.chunk_group
+  IS 'Columnar chunk group information for tables on which the current user has ownership privileges.';
+GRANT SELECT ON columnar.chunk_group TO PUBLIC;
+
+CREATE VIEW columnar.chunk WITH (security_barrier) AS
+  SELECT relation, storage.storage_id, stripe_num, attr_num, chunk_group_num,
+         minimum_value, maximum_value, value_stream_offset, value_stream_length,
+         exists_stream_offset, exists_stream_length, value_compression_type,
+         value_compression_level, value_decompressed_length, value_count
+    FROM columnar_internal.chunk chunk, columnar.storage storage
+    WHERE chunk.storage_id = storage.storage_id;
+COMMENT ON VIEW columnar.chunk
+  IS 'Columnar chunk information for tables on which the current user has ownership privileges.';
+GRANT SELECT ON columnar.chunk TO PUBLIC;

src/backend/columnar/sql/downgrades/columnar--11.1-1--11.0-2.sql

@@ -1,2 +1,19 @@
 #include "../udfs/alter_columnar_table_set/10.0-1.sql"
 #include "../udfs/alter_columnar_table_reset/10.0-1.sql"
+
+#include "../udfs/columnar_ensure_am_depends_catalog/10.2-4.sql"
+
+DROP VIEW columnar.options;
+DROP VIEW columnar.stripe;
+DROP VIEW columnar.chunk_group;
+DROP VIEW columnar.chunk;
+DROP VIEW columnar.storage;
+DROP FUNCTION columnar.get_storage_id(regclass);
+
+DROP SCHEMA columnar;
+
+ALTER SCHEMA columnar_internal RENAME TO columnar;
+GRANT USAGE ON SCHEMA columnar TO PUBLIC;
+GRANT SELECT ON columnar.options TO PUBLIC;
+GRANT SELECT ON columnar.stripe TO PUBLIC;
+GRANT SELECT ON columnar.chunk_group TO PUBLIC;

src/backend/columnar/sql/udfs/columnar_ensure_am_depends_catalog/11.1-1.sql

@@ -0,0 +1,48 @@
+CREATE OR REPLACE FUNCTION citus_internal.columnar_ensure_am_depends_catalog()
+  RETURNS void
+  LANGUAGE plpgsql
+  SET search_path = pg_catalog
+AS $func$
+BEGIN
+  INSERT INTO pg_depend
+  WITH columnar_schema_members(relid) AS (
+    SELECT pg_class.oid AS relid FROM pg_class
+      WHERE relnamespace =
+            COALESCE(
+	       (SELECT pg_namespace.oid FROM pg_namespace WHERE nspname = 'columnar_internal'),
+	       (SELECT pg_namespace.oid FROM pg_namespace WHERE nspname = 'columnar')
+	    )
+        AND relname IN ('chunk',
+                        'chunk_group',
+                        'chunk_group_pkey',
+                        'chunk_pkey',
+                        'options',
+                        'options_pkey',
+                        'storageid_seq',
+                        'stripe',
+                        'stripe_first_row_number_idx',
+                        'stripe_pkey')
+  )
+  SELECT -- Define a dependency edge from "columnar table access method" ..
+         'pg_am'::regclass::oid as classid,
+         (select oid from pg_am where amname = 'columnar') as objid,
+         0 as objsubid,
+         -- ... to each object that is registered to pg_class and that lives
+         -- in "columnar" schema. That contains catalog tables, indexes
+         -- created on them and the sequences created in "columnar" schema.
+         --
+         -- Given the possibility of user might have created their own objects
+         -- in columnar schema, we explicitly specify list of objects that we
+         -- are interested in.
+         'pg_class'::regclass::oid as refclassid,
+         columnar_schema_members.relid as refobjid,
+         0 as refobjsubid,
+         'n' as deptype
+  FROM columnar_schema_members
+  -- Avoid inserting duplicate entries into pg_depend.
+  EXCEPT TABLE pg_depend;
+END;
+$func$;
+COMMENT ON FUNCTION citus_internal.columnar_ensure_am_depends_catalog()
+  IS 'internal function responsible for creating dependencies from columnar '
+     'table access method to the rel objects in columnar schema';

src/backend/columnar/sql/udfs/columnar_ensure_am_depends_catalog/latest.sql

@@ -5,6 +5,24 @@ CREATE OR REPLACE FUNCTION citus_internal.columnar_ensure_am_depends_catalog()
 AS $func$
 BEGIN
   INSERT INTO pg_depend
+  WITH columnar_schema_members(relid) AS (
+    SELECT pg_class.oid AS relid FROM pg_class
+      WHERE relnamespace =
+            COALESCE(
+	       (SELECT pg_namespace.oid FROM pg_namespace WHERE nspname = 'columnar_internal'),
+	       (SELECT pg_namespace.oid FROM pg_namespace WHERE nspname = 'columnar')
+	    )
+        AND relname IN ('chunk',
+                        'chunk_group',
+                        'chunk_group_pkey',
+                        'chunk_pkey',
+                        'options',
+                        'options_pkey',
+                        'storageid_seq',
+                        'stripe',
+                        'stripe_first_row_number_idx',
+                        'stripe_pkey')
+  )
   SELECT -- Define a dependency edge from "columnar table access method" ..
          'pg_am'::regclass::oid as classid,
          (select oid from pg_am where amname = 'columnar') as objid,
@@ -17,20 +35,10 @@ BEGIN
          -- in columnar schema, we explicitly specify list of objects that we
          -- are interested in.
          'pg_class'::regclass::oid as refclassid,
-         columnar_schema_members.relname::regclass::oid as refobjid,
+         columnar_schema_members.relid as refobjid,
          0 as refobjsubid,
          'n' as deptype
-  FROM (VALUES ('columnar.chunk'),
+  FROM columnar_schema_members
-               ('columnar.chunk_group'),
-               ('columnar.chunk_group_pkey'),
-               ('columnar.chunk_pkey'),
-               ('columnar.options'),
-               ('columnar.options_pkey'),
-               ('columnar.storageid_seq'),
-               ('columnar.stripe'),
-               ('columnar.stripe_first_row_number_idx'),
-               ('columnar.stripe_pkey')
-       ) columnar_schema_members(relname)
   -- Avoid inserting duplicate entries into pg_depend.
   EXCEPT TABLE pg_depend;
 END;

src/test/regress/expected/columnar_citus_integration.out

@@ -35,7 +35,7 @@ SELECT create_distributed_table('table_option', 'a');
 -- setting: compression
 -- get baseline for setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -49,7 +49,7 @@ $cmd$);
 ALTER TABLE table_option SET (columnar.compression = pglz);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -63,7 +63,7 @@ $cmd$);
 ALTER TABLE table_option RESET (columnar.compression);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -76,7 +76,7 @@ $cmd$);
 -- setting: compression_level
 -- get baseline for setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
    run_command_on_placements
 ---------------------------------------------------------------------
@@ -90,7 +90,7 @@ $cmd$);
 ALTER TABLE table_option SET (columnar.compression_level = 13);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
     run_command_on_placements
 ---------------------------------------------------------------------
@@ -104,7 +104,7 @@ $cmd$);
 ALTER TABLE table_option RESET (columnar.compression_level);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
    run_command_on_placements
 ---------------------------------------------------------------------
@@ -117,7 +117,7 @@ $cmd$);
 -- setting: chunk_group_row_limit
 -- get baseline for setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -131,7 +131,7 @@ $cmd$);
 ALTER TABLE table_option SET (columnar.chunk_group_row_limit = 2000);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -145,7 +145,7 @@ $cmd$);
 ALTER TABLE table_option RESET (columnar.chunk_group_row_limit);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -158,7 +158,7 @@ $cmd$);
 -- setting: stripe_row_limit
 -- get baseline for setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
       run_command_on_placements
 ---------------------------------------------------------------------
@@ -172,7 +172,7 @@ $cmd$);
 ALTER TABLE table_option SET (columnar.stripe_row_limit = 2000);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -186,7 +186,7 @@ $cmd$);
 ALTER TABLE table_option RESET (columnar.stripe_row_limit);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
       run_command_on_placements
 ---------------------------------------------------------------------
@@ -211,7 +211,7 @@ SELECT create_distributed_table('table_option_2', 'a');
 
 -- verify settings on placements
 SELECT run_command_on_placements('table_option_2',$cmd$
-  SELECT ROW(chunk_group_row_limit, stripe_row_limit, compression, compression_level) FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT ROW(chunk_group_row_limit, stripe_row_limit, compression, compression_level) FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
               run_command_on_placements
 ---------------------------------------------------------------------
@@ -237,7 +237,7 @@ SELECT * FROM pg_dist_partition WHERE logicalrelid = 'table_option'::regclass;
 ---------------------------------------------------------------------
 (0 rows)
 
-SELECT compression FROM columnar.options WHERE regclass = 'table_option'::regclass;
+SELECT compression FROM columnar.options WHERE relation = 'table_option'::regclass;
  compression
 ---------------------------------------------------------------------
  none
@@ -257,7 +257,7 @@ SELECT create_distributed_table('table_option', 'a');
 -- setting: compression
 -- get baseline for setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -275,7 +275,7 @@ $cmd$);
 ALTER TABLE table_option SET (columnar.compression = pglz);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -293,7 +293,7 @@ $cmd$);
 ALTER TABLE table_option RESET (columnar.compression);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -310,7 +310,7 @@ $cmd$);
 -- setting: compression_level
 -- get baseline for setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
    run_command_on_placements
 ---------------------------------------------------------------------
@@ -328,7 +328,7 @@ $cmd$);
 ALTER TABLE table_option SET (columnar.compression_level = 17);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
     run_command_on_placements
 ---------------------------------------------------------------------
@@ -346,7 +346,7 @@ $cmd$);
 ALTER TABLE table_option RESET (columnar.compression_level);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
    run_command_on_placements
 ---------------------------------------------------------------------
@@ -363,7 +363,7 @@ $cmd$);
 -- setting: chunk_group_row_limit
 -- get baseline for setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -381,7 +381,7 @@ $cmd$);
 ALTER TABLE table_option SET (columnar.chunk_group_row_limit = 2000);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -399,7 +399,7 @@ $cmd$);
 ALTER TABLE table_option RESET (columnar.chunk_group_row_limit);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -416,7 +416,7 @@ $cmd$);
 -- setting: stripe_row_limit
 -- get baseline for setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
       run_command_on_placements
 ---------------------------------------------------------------------
@@ -434,7 +434,7 @@ $cmd$);
 ALTER TABLE table_option SET (columnar.stripe_row_limit = 2000);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -452,7 +452,7 @@ $cmd$);
 ALTER TABLE table_option RESET (columnar.stripe_row_limit);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
       run_command_on_placements
 ---------------------------------------------------------------------
@@ -481,7 +481,7 @@ SELECT create_distributed_table('table_option_2', 'a');
 
 -- verify settings on placements
 SELECT run_command_on_placements('table_option_2',$cmd$
-  SELECT ROW(chunk_group_row_limit, stripe_row_limit, compression, compression_level) FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT ROW(chunk_group_row_limit, stripe_row_limit, compression, compression_level) FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
               run_command_on_placements
 ---------------------------------------------------------------------
@@ -511,7 +511,7 @@ SELECT * FROM pg_dist_partition WHERE logicalrelid = 'table_option'::regclass;
 ---------------------------------------------------------------------
 (0 rows)
 
-SELECT compression FROM columnar.options WHERE regclass = 'table_option'::regclass;
+SELECT compression FROM columnar.options WHERE relation = 'table_option'::regclass;
  compression
 ---------------------------------------------------------------------
  none
@@ -529,7 +529,7 @@ SELECT create_reference_table('table_option_reference');
 -- setting: compression
 -- get baseline for setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -541,7 +541,7 @@ $cmd$);
 ALTER TABLE table_option_reference SET (columnar.compression = pglz);
 -- verify setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -553,7 +553,7 @@ $cmd$);
 ALTER TABLE table_option_reference RESET (columnar.compression);
 -- verify setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -564,7 +564,7 @@ $cmd$);
 -- setting: compression_level
 -- get baseline for setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
    run_command_on_placements
 ---------------------------------------------------------------------
@@ -576,7 +576,7 @@ $cmd$);
 ALTER TABLE table_option_reference SET (columnar.compression_level = 11);
 -- verify setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
     run_command_on_placements
 ---------------------------------------------------------------------
@@ -588,7 +588,7 @@ $cmd$);
 ALTER TABLE table_option_reference RESET (columnar.compression_level);
 -- verify setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
    run_command_on_placements
 ---------------------------------------------------------------------
@@ -599,7 +599,7 @@ $cmd$);
 -- setting: chunk_group_row_limit
 -- get baseline for setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -611,7 +611,7 @@ $cmd$);
 ALTER TABLE table_option_reference SET (columnar.chunk_group_row_limit = 2000);
 -- verify setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -623,7 +623,7 @@ $cmd$);
 ALTER TABLE table_option_reference RESET (columnar.chunk_group_row_limit);
 -- verify setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -634,7 +634,7 @@ $cmd$);
 -- setting: stripe_row_limit
 -- get baseline for setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
       run_command_on_placements
 ---------------------------------------------------------------------
@@ -646,7 +646,7 @@ $cmd$);
 ALTER TABLE table_option_reference SET (columnar.stripe_row_limit = 2000);
 -- verify setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -658,7 +658,7 @@ $cmd$);
 ALTER TABLE table_option_reference RESET (columnar.stripe_row_limit);
 -- verify setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
       run_command_on_placements
 ---------------------------------------------------------------------
@@ -681,7 +681,7 @@ SELECT create_reference_table('table_option_reference_2');
 
 -- verify settings on placements
 SELECT run_command_on_placements('table_option_reference_2',$cmd$
-  SELECT ROW(chunk_group_row_limit, stripe_row_limit, compression, compression_level) FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT ROW(chunk_group_row_limit, stripe_row_limit, compression, compression_level) FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
              run_command_on_placements
 ---------------------------------------------------------------------
@@ -705,7 +705,7 @@ SELECT * FROM pg_dist_partition WHERE logicalrelid = 'table_option_reference'::r
 ---------------------------------------------------------------------
 (0 rows)
 
-SELECT compression FROM columnar.options WHERE regclass = 'table_option_reference'::regclass;
+SELECT compression FROM columnar.options WHERE relation = 'table_option_reference'::regclass;
  compression
 ---------------------------------------------------------------------
  none
@@ -731,7 +731,7 @@ SELECT citus_add_local_table_to_metadata('table_option_citus_local');
 -- setting: compression
 -- get baseline for setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -742,7 +742,7 @@ $cmd$);
 ALTER TABLE table_option_citus_local SET (columnar.compression = pglz);
 -- verify setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -753,7 +753,7 @@ $cmd$);
 ALTER TABLE table_option_citus_local RESET (columnar.compression);
 -- verify setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -763,7 +763,7 @@ $cmd$);
 -- setting: compression_level
 -- get baseline for setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
    run_command_on_placements
 ---------------------------------------------------------------------
@@ -774,7 +774,7 @@ $cmd$);
 ALTER TABLE table_option_citus_local SET (columnar.compression_level = 11);
 -- verify setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
     run_command_on_placements
 ---------------------------------------------------------------------
@@ -785,7 +785,7 @@ $cmd$);
 ALTER TABLE table_option_citus_local RESET (columnar.compression_level);
 -- verify setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
    run_command_on_placements
 ---------------------------------------------------------------------
@@ -795,7 +795,7 @@ $cmd$);
 -- setting: chunk_group_row_limit
 -- get baseline for setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -806,7 +806,7 @@ $cmd$);
 ALTER TABLE table_option_citus_local SET (columnar.chunk_group_row_limit = 2000);
 -- verify setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -817,7 +817,7 @@ $cmd$);
 ALTER TABLE table_option_citus_local RESET (columnar.chunk_group_row_limit);
 -- verify setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -827,7 +827,7 @@ $cmd$);
 -- setting: stripe_row_limit
 -- get baseline for setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
       run_command_on_placements
 ---------------------------------------------------------------------
@@ -838,7 +838,7 @@ $cmd$);
 ALTER TABLE table_option_citus_local SET (columnar.stripe_row_limit = 2000);
 -- verify setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
      run_command_on_placements
 ---------------------------------------------------------------------
@@ -849,7 +849,7 @@ $cmd$);
 ALTER TABLE table_option_citus_local RESET (columnar.stripe_row_limit);
 -- verify setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
       run_command_on_placements
 ---------------------------------------------------------------------
@@ -871,7 +871,7 @@ SELECT citus_add_local_table_to_metadata('table_option_citus_local_2');
 
 -- verify settings on placements
 SELECT run_command_on_placements('table_option_citus_local_2',$cmd$
-  SELECT ROW(chunk_group_row_limit, stripe_row_limit, compression, compression_level) FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT ROW(chunk_group_row_limit, stripe_row_limit, compression, compression_level) FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
              run_command_on_placements
 ---------------------------------------------------------------------
@@ -894,7 +894,7 @@ SELECT * FROM pg_dist_partition WHERE logicalrelid = 'table_option_citus_local':
 ---------------------------------------------------------------------
 (0 rows)
 
-SELECT compression FROM columnar.options WHERE regclass = 'table_option_citus_local'::regclass;
+SELECT compression FROM columnar.options WHERE relation = 'table_option_citus_local'::regclass;
  compression
 ---------------------------------------------------------------------
  none

src/test/regress/expected/columnar_create.out

@@ -26,7 +26,7 @@ CREATE TABLE columnar_table_1 (a int) USING columnar;
 INSERT INTO columnar_table_1 VALUES (1);
 CREATE MATERIALIZED VIEW columnar_table_1_mv USING columnar
 AS SELECT * FROM columnar_table_1;
-SELECT columnar_test_helpers.columnar_relation_storageid(oid) AS columnar_table_1_mv_storage_id
+SELECT columnar.get_storage_id(oid) AS columnar_table_1_mv_storage_id
 FROM pg_class WHERE relname='columnar_table_1_mv' \gset
 -- test columnar_relation_set_new_filenode
 REFRESH MATERIALIZED VIEW columnar_table_1_mv;
@@ -36,7 +36,7 @@ SELECT columnar_test_helpers.columnar_metadata_has_storage_id(:columnar_table_1_
  f
 (1 row)
 
-SELECT columnar_test_helpers.columnar_relation_storageid(oid) AS columnar_table_1_storage_id
+SELECT columnar.get_storage_id(oid) AS columnar_table_1_storage_id
 FROM pg_class WHERE relname='columnar_table_1' \gset
 BEGIN;
   -- test columnar_relation_nontransactional_truncate
@@ -69,7 +69,7 @@ SELECT columnar_test_helpers.columnar_metadata_has_storage_id(:columnar_table_1_
 CREATE TEMPORARY TABLE columnar_temp(i int) USING columnar;
 -- reserve some chunks and a stripe
 INSERT INTO columnar_temp SELECT i FROM generate_series(1,5) i;
-SELECT columnar_test_helpers.columnar_relation_storageid(oid) AS columnar_temp_storage_id
+SELECT columnar.get_storage_id(oid) AS columnar_temp_storage_id
 FROM pg_class WHERE relname='columnar_temp' \gset
 SELECT pg_backend_pid() AS val INTO old_backend_pid;
 \c - - - :master_port
@@ -105,7 +105,7 @@ SELECT COUNT(*) FROM columnar_temp WHERE i < 5;
      4
 (1 row)
 
-SELECT columnar_test_helpers.columnar_relation_storageid(oid) AS columnar_temp_storage_id
+SELECT columnar.get_storage_id(oid) AS columnar_temp_storage_id
 FROM pg_class WHERE relname='columnar_temp' \gset
 BEGIN;
   DROP TABLE columnar_temp;
@@ -137,7 +137,7 @@ BEGIN;
   CREATE TEMPORARY TABLE columnar_temp(i int) USING columnar ON COMMIT DROP;
   -- force flushing stripe
   INSERT INTO columnar_temp SELECT i FROM generate_series(1,150000) i;
-  SELECT columnar_test_helpers.columnar_relation_storageid(oid) AS columnar_temp_storage_id
+  SELECT columnar.get_storage_id(oid) AS columnar_temp_storage_id
   FROM pg_class WHERE relname='columnar_temp' \gset
 COMMIT;
 -- make sure that table & it's stripe is dropped after commiting above xact
@@ -157,7 +157,7 @@ BEGIN;
   CREATE TEMPORARY TABLE columnar_temp(i int) USING columnar ON COMMIT DELETE ROWS;
   -- force flushing stripe
   INSERT INTO columnar_temp SELECT i FROM generate_series(1,150000) i;
-  SELECT columnar_test_helpers.columnar_relation_storageid(oid) AS columnar_temp_storage_id
+  SELECT columnar.get_storage_id(oid) AS columnar_temp_storage_id
   FROM pg_class WHERE relname='columnar_temp' \gset
 COMMIT;
 -- make sure that table is not dropped but it's rows's are deleted after commiting above xact

src/test/regress/expected/columnar_empty.out

@@ -8,10 +8,10 @@ create table t_compressed(a int) using columnar;
 ALTER TABLE t_compressed SET (columnar.compression = pglz);
 ALTER TABLE t_compressed SET (columnar.stripe_row_limit = 2000);
 ALTER TABLE t_compressed SET (columnar.chunk_group_row_limit = 1000);
-SELECT * FROM columnar.options WHERE regclass = 't_compressed'::regclass;
+SELECT * FROM columnar.options WHERE relation = 't_compressed'::regclass;
-   regclass   | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation   | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- t_compressed |                  1000 |             2000 |                 3 | pglz
+ t_compressed |                  1000 |             2000 | pglz        |                 3
 (1 row)
 
 -- select

src/test/regress/expected/columnar_first_row_number.out

@@ -10,7 +10,7 @@ INSERT INTO col_table_1 SELECT i FROM generate_series(1, 12) i;
 ALTER TABLE col_table_1 SET (columnar.stripe_row_limit = 1000);
 INSERT INTO col_table_1 SELECT i FROM generate_series(1, 2350) i;
 SELECT row_count, first_row_number FROM columnar.stripe a
-WHERE a.storage_id = columnar_test_helpers.columnar_relation_storageid('col_table_1'::regclass)
+WHERE a.storage_id = columnar.get_storage_id('col_table_1'::regclass)
 ORDER BY stripe_num;
  row_count | first_row_number
 ---------------------------------------------------------------------
@@ -24,7 +24,7 @@ ORDER BY stripe_num;
 VACUUM FULL col_table_1;
 -- show that we properly update first_row_number after VACUUM FULL
 SELECT row_count, first_row_number FROM columnar.stripe a
-WHERE a.storage_id = columnar_test_helpers.columnar_relation_storageid('col_table_1'::regclass)
+WHERE a.storage_id = columnar.get_storage_id('col_table_1'::regclass)
 ORDER BY stripe_num;
  row_count | first_row_number
 ---------------------------------------------------------------------
@@ -40,7 +40,7 @@ BEGIN;
 COMMIT;
 -- show that we start with first_row_number=1 after TRUNCATE
 SELECT row_count, first_row_number FROM columnar.stripe a
-WHERE a.storage_id = columnar_test_helpers.columnar_relation_storageid('col_table_1'::regclass)
+WHERE a.storage_id = columnar.get_storage_id('col_table_1'::regclass)
 ORDER BY stripe_num;
  row_count | first_row_number
 ---------------------------------------------------------------------

src/test/regress/expected/columnar_indexes.out

@@ -545,11 +545,11 @@ DETAIL:  Key (a)=(16999) already exists.
 -- since second INSERT already failed, should not throw a "duplicate key" error
 REINDEX TABLE aborted_write_test;
 BEGIN;
-  ALTER TABLE columnar.stripe SET (autovacuum_enabled = false);
+  ALTER TABLE columnar_internal.stripe SET (autovacuum_enabled = false);
-  ALTER TABLE columnar.chunk SET (autovacuum_enabled = false);
+  ALTER TABLE columnar_internal.chunk SET (autovacuum_enabled = false);
-  ALTER TABLE columnar.chunk_group SET (autovacuum_enabled = false);
+  ALTER TABLE columnar_internal.chunk_group SET (autovacuum_enabled = false);
   DROP TABLE aborted_write_test;
-  TRUNCATE columnar.stripe, columnar.chunk, columnar.chunk_group;
+  TRUNCATE columnar_internal.stripe, columnar_internal.chunk, columnar_internal.chunk_group;
   CREATE TABLE aborted_write_test (a INT) USING columnar;
   SAVEPOINT svpt;
     INSERT INTO aborted_write_test SELECT i FROM generate_series(1, 2) i;
@@ -559,12 +559,13 @@ BEGIN;
 (2 rows)
 
   ROLLBACK TO SAVEPOINT svpt;
-  -- Already disabled autovacuum for all three metadata tables.
+  -- Already disabled autovacuum for all three metadata tables.  Here
-  -- Here we truncate columnar.chunk and columnar.chunk_group but not
+  -- we truncate columnar_internal.chunk and
-  -- columnar.stripe to make sure that we properly handle dead tuples
+  -- columnar.chunk_group but not columnar.stripe to
-  -- in columnar.stripe, i.e. stripe metadata entries for aborted
+  -- make sure that we properly handle dead tuples in
-  -- transactions.
+  -- columnar.stripe, i.e. stripe metadata entries for
-  TRUNCATE columnar.chunk, columnar.chunk_group;
+  -- aborted transactions.
+  TRUNCATE columnar_internal.chunk, columnar_internal.chunk_group;
   CREATE INDEX ON aborted_write_test (a);
 ROLLBACK;
 create table events (event_id bigserial, event_time timestamptz default now(), payload text) using columnar;
@@ -611,7 +612,7 @@ begin;
 rollback;
 insert into uniq select generate_series(1,100);
 SELECT COUNT(*)=1 FROM columnar.stripe cs
-WHERE cs.storage_id = columnar_test_helpers.columnar_relation_storageid('columnar_indexes.uniq'::regclass);
+WHERE cs.storage_id = columnar.get_storage_id('columnar_indexes.uniq'::regclass);
  ?column?
 ---------------------------------------------------------------------
  t
@@ -630,7 +631,7 @@ begin;
 rollback;
 insert into uniq select generate_series(1,100);
 SELECT COUNT(*)=1 FROM columnar.stripe cs
-WHERE cs.storage_id = columnar_test_helpers.columnar_relation_storageid('columnar_indexes.uniq'::regclass);
+WHERE cs.storage_id = columnar.get_storage_id('columnar_indexes.uniq'::regclass);
  ?column?
 ---------------------------------------------------------------------
  t
@@ -644,7 +645,7 @@ begin;
 rollback;
 insert into uniq select generate_series(1,100);
 SELECT COUNT(*)=1 FROM columnar.stripe cs
-WHERE cs.storage_id = columnar_test_helpers.columnar_relation_storageid('columnar_indexes.uniq'::regclass);
+WHERE cs.storage_id = columnar.get_storage_id('columnar_indexes.uniq'::regclass);
  ?column?
 ---------------------------------------------------------------------
  t
@@ -663,7 +664,7 @@ begin;
 rollback;
 insert into uniq select generate_series(1,100);
 SELECT COUNT(*)=1 FROM columnar.stripe cs
-WHERE cs.storage_id = columnar_test_helpers.columnar_relation_storageid('columnar_indexes.uniq'::regclass);
+WHERE cs.storage_id = columnar.get_storage_id('columnar_indexes.uniq'::regclass);
  ?column?
 ---------------------------------------------------------------------
  t
@@ -680,7 +681,7 @@ begin;
   insert into uniq select generate_series(1,100);
   -- didn't flush anything yet, but should see the in progress stripe-write
   SELECT stripe_num, first_row_number, row_count FROM columnar.stripe cs
-  WHERE cs.storage_id = columnar_test_helpers.columnar_relation_storageid('columnar_indexes.uniq'::regclass);
+  WHERE cs.storage_id = columnar.get_storage_id('columnar_indexes.uniq'::regclass);
  stripe_num | first_row_number | row_count
 ---------------------------------------------------------------------
           2 |           150001 |         0
@@ -689,7 +690,7 @@ begin;
 commit;
 -- should have completed the stripe reservation
 SELECT stripe_num, first_row_number, row_count FROM columnar.stripe cs
-WHERE cs.storage_id = columnar_test_helpers.columnar_relation_storageid('columnar_indexes.uniq'::regclass);
+WHERE cs.storage_id = columnar.get_storage_id('columnar_indexes.uniq'::regclass);
  stripe_num | first_row_number | row_count
 ---------------------------------------------------------------------
           2 |           150001 |       100

src/test/regress/expected/columnar_insert.out

@@ -195,7 +195,7 @@ select
 (1 row)
 
 SELECT relname, stripe_num, chunk_group_count, row_count FROM columnar.stripe a, pg_class b
-WHERE columnar_test_helpers.columnar_relation_storageid(b.oid)=a.storage_id AND relname = 'zero_col'
+WHERE columnar.get_storage_id(b.oid)=a.storage_id AND relname = 'zero_col'
 ORDER BY 1,2,3,4;
  relname  | stripe_num | chunk_group_count | row_count
 ---------------------------------------------------------------------
@@ -207,14 +207,14 @@ ORDER BY 1,2,3,4;
 (5 rows)
 
 SELECT relname, stripe_num, value_count FROM columnar.chunk a, pg_class b
-WHERE columnar_test_helpers.columnar_relation_storageid(b.oid)=a.storage_id AND relname = 'zero_col'
+WHERE columnar.get_storage_id(b.oid)=a.storage_id AND relname = 'zero_col'
 ORDER BY 1,2,3;
  relname | stripe_num | value_count
 ---------------------------------------------------------------------
 (0 rows)
 
 SELECT relname, stripe_num, chunk_group_num, row_count FROM columnar.chunk_group a, pg_class b
-WHERE columnar_test_helpers.columnar_relation_storageid(b.oid)=a.storage_id AND relname = 'zero_col'
+WHERE columnar.get_storage_id(b.oid)=a.storage_id AND relname = 'zero_col'
 ORDER BY 1,2,3,4;
  relname  | stripe_num | chunk_group_num | row_count
 ---------------------------------------------------------------------

src/test/regress/expected/columnar_matview.out

@@ -25,28 +25,28 @@ SELECT * FROM t_view a ORDER BY a;
 
 -- show columnar options for materialized view
 SELECT * FROM columnar.options
-WHERE regclass = 't_view'::regclass;
+WHERE relation = 't_view'::regclass;
- regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+ relation | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- t_view   |           10000 |           150000 |                 3 | none
+ t_view   |                 10000 |           150000 | none        |                 3
 (1 row)
 
 -- show we can set options on a materialized view
 ALTER TABLE t_view SET (columnar.compression = pglz);
 SELECT * FROM columnar.options
-WHERE regclass = 't_view'::regclass;
+WHERE relation = 't_view'::regclass;
- regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+ relation | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- t_view   |           10000 |           150000 |                 3 | pglz
+ t_view   |                 10000 |           150000 | pglz        |                 3
 (1 row)
 
 REFRESH MATERIALIZED VIEW t_view;
 -- verify options have not been changed
 SELECT * FROM columnar.options
-WHERE regclass = 't_view'::regclass;
+WHERE relation = 't_view'::regclass;
- regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+ relation | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- t_view   |           10000 |           150000 |                 3 | pglz
+ t_view   |                 10000 |           150000 | pglz        |                 3
 (1 row)
 
 SELECT * FROM t_view a ORDER BY a;
@@ -61,7 +61,7 @@ SELECT * FROM t_view a ORDER BY a;
 (6 rows)
 
 -- verify that we have created metadata entries for the materialized view
-SELECT columnar_test_helpers.columnar_relation_storageid(oid) AS storageid
+SELECT columnar.get_storage_id(oid) AS storageid
 FROM pg_class WHERE relname='t_view' \gset
 SELECT count(*) FROM columnar.stripe WHERE storage_id=:storageid;
  count

src/test/regress/expected/columnar_permissions.out

@@ -1,11 +1,16 @@
 create table no_access (i int) using columnar;
+insert into no_access values(1);
+insert into no_access values(2);
+insert into no_access values(3);
 select current_user \gset
 create user columnar_user;
 NOTICE:  not propagating CREATE ROLE/USER commands to worker nodes
 HINT:  Connect to worker nodes directly to manually create all necessary users and roles.
 \c - columnar_user
+-- owned by columnar_user
 create table columnar_permissions(i int) using columnar;
 insert into columnar_permissions values(1);
+insert into columnar_permissions values(2);
 alter table columnar_permissions add column j int;
 alter table columnar_permissions reset (columnar.compression);
 alter table columnar_permissions set (columnar.compression = none);
@@ -21,17 +26,58 @@ select alter_columnar_table_set('columnar_permissions', stripe_row_limit => 2222
 
 (1 row)
 
-select * from columnar.options where regclass = 'columnar_permissions'::regclass;
+select 1 from columnar.get_storage_id('columnar_permissions'::regclass);
-       regclass       | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+ ?column?
 ---------------------------------------------------------------------
- columnar_permissions |                 10000 |             2222 |                 3 | none
+        1
 (1 row)
 
-insert into columnar_permissions values(2,20);
+-- error
-vacuum columnar_permissions;
+select 1 from columnar.get_storage_id('no_access'::regclass);
+ERROR:  must be owner of table no_access
+-- only tuples related to columnar_permissions should be visible
+select relation, chunk_group_row_limit, stripe_row_limit, compression, compression_level
+  from columnar.options
+  where relation in ('no_access'::regclass, 'columnar_permissions'::regclass);
+       relation       | chunk_group_row_limit | stripe_row_limit | compression | compression_level
+---------------------------------------------------------------------
+ columnar_permissions |                 10000 |             2222 | none        |                 3
+(1 row)
+
+select relation, stripe_num, row_count, first_row_number
+  from columnar.stripe
+  where relation in ('no_access'::regclass, 'columnar_permissions'::regclass);
+       relation       | stripe_num | row_count | first_row_number
+---------------------------------------------------------------------
+ columnar_permissions |          1 |         1 |                1
+ columnar_permissions |          2 |         1 |           150001
+(2 rows)
+
+select relation, stripe_num, attr_num, chunk_group_num, value_count
+  from columnar.chunk
+  where relation in ('no_access'::regclass, 'columnar_permissions'::regclass);
+       relation       | stripe_num | attr_num | chunk_group_num | value_count
+---------------------------------------------------------------------
+ columnar_permissions |          1 |        1 |               0 |           1
+ columnar_permissions |          2 |        1 |               0 |           1
+(2 rows)
+
+select relation, stripe_num, chunk_group_num, row_count
+  from columnar.chunk_group
+  where relation in ('no_access'::regclass, 'columnar_permissions'::regclass);
+       relation       | stripe_num | chunk_group_num | row_count
+---------------------------------------------------------------------
+ columnar_permissions |          1 |               0 |         1
+ columnar_permissions |          2 |               0 |         1
+(2 rows)
+
 truncate columnar_permissions;
-drop table columnar_permissions;
+insert into columnar_permissions values(2,20);
--- should error
+insert into columnar_permissions values(2,30);
+insert into columnar_permissions values(4,40);
+insert into columnar_permissions values(5,50);
+vacuum columnar_permissions;
+-- error: columnar_user can't alter no_access
 alter table no_access reset (columnar.stripe_row_limit);
 ERROR:  must be owner of table no_access
 alter table no_access set (columnar.stripe_row_limit = 12000);
@@ -45,3 +91,61 @@ ERROR:  must be owner of table no_access
 CONTEXT:  SQL statement "ALTER TABLE no_access SET (columnar.chunk_group_row_limit=1111)"
 PL/pgSQL function alter_columnar_table_set(regclass,integer,integer,name,integer) line XX at EXECUTE
 \c - :current_user
+-- should see tuples from both columnar_permissions and no_access
+select relation, chunk_group_row_limit, stripe_row_limit, compression, compression_level
+  from columnar.options
+  where relation in ('no_access'::regclass, 'columnar_permissions'::regclass);
+       relation       | chunk_group_row_limit | stripe_row_limit | compression | compression_level
+---------------------------------------------------------------------
+ no_access            |                 10000 |           150000 | zstd        |                 3
+ columnar_permissions |                 10000 |             2222 | none        |                 3
+(2 rows)
+
+select relation, stripe_num, row_count, first_row_number
+  from columnar.stripe
+  where relation in ('no_access'::regclass, 'columnar_permissions'::regclass);
+       relation       | stripe_num | row_count | first_row_number
+---------------------------------------------------------------------
+ no_access            |          1 |         1 |                1
+ no_access            |          2 |         1 |           150001
+ no_access            |          3 |         1 |           300001
+ columnar_permissions |          1 |         1 |                1
+ columnar_permissions |          2 |         1 |             2223
+ columnar_permissions |          3 |         1 |             4445
+ columnar_permissions |          4 |         1 |             6667
+(7 rows)
+
+select relation, stripe_num, attr_num, chunk_group_num, value_count
+  from columnar.chunk
+  where relation in ('no_access'::regclass, 'columnar_permissions'::regclass);
+       relation       | stripe_num | attr_num | chunk_group_num | value_count
+---------------------------------------------------------------------
+ no_access            |          1 |        1 |               0 |           1
+ no_access            |          2 |        1 |               0 |           1
+ no_access            |          3 |        1 |               0 |           1
+ columnar_permissions |          1 |        1 |               0 |           1
+ columnar_permissions |          1 |        2 |               0 |           1
+ columnar_permissions |          2 |        1 |               0 |           1
+ columnar_permissions |          2 |        2 |               0 |           1
+ columnar_permissions |          3 |        1 |               0 |           1
+ columnar_permissions |          3 |        2 |               0 |           1
+ columnar_permissions |          4 |        1 |               0 |           1
+ columnar_permissions |          4 |        2 |               0 |           1
+(11 rows)
+
+select relation, stripe_num, chunk_group_num, row_count
+  from columnar.chunk_group
+  where relation in ('no_access'::regclass, 'columnar_permissions'::regclass);
+       relation       | stripe_num | chunk_group_num | row_count
+---------------------------------------------------------------------
+ no_access            |          1 |               0 |         1
+ no_access            |          2 |               0 |         1
+ no_access            |          3 |               0 |         1
+ columnar_permissions |          1 |               0 |         1
+ columnar_permissions |          2 |               0 |         1
+ columnar_permissions |          3 |               0 |         1
+ columnar_permissions |          4 |               0 |         1
+(7 rows)
+
+drop table columnar_permissions;
+drop table no_access;

src/test/regress/expected/columnar_recursive.out

@@ -12,7 +12,7 @@ INSERT INTO t2 SELECT i, f(i) FROM generate_series(1, 5) i;
 -- there are no subtransactions, so above statement should batch
 -- INSERTs inside the UDF and create on stripe per table.
 SELECT relname, count(*) FROM columnar.stripe a, pg_class b
-WHERE columnar_test_helpers.columnar_relation_storageid(b.oid)=a.storage_id AND relname IN ('t1', 't2')
+WHERE columnar.get_storage_id(b.oid)=a.storage_id AND relname IN ('t1', 't2')
 GROUP BY relname
 ORDER BY relname;
  relname | count

src/test/regress/expected/columnar_rollback.out

@@ -4,7 +4,7 @@
 CREATE TABLE t(a int, b int) USING columnar;
 CREATE VIEW t_stripes AS
 SELECT * FROM columnar.stripe a, pg_class b
-WHERE a.storage_id = columnar_test_helpers.columnar_relation_storageid(b.oid) AND b.relname = 't';
+WHERE a.storage_id = columnar.get_storage_id(b.oid) AND b.relname = 't';
 BEGIN;
 INSERT INTO t SELECT i, i+1 FROM generate_series(1, 10) i;
 ROLLBACK;

src/test/regress/expected/columnar_tableoptions.out

@@ -5,60 +5,60 @@ CREATE TABLE table_options (a int) USING columnar;
 INSERT INTO table_options SELECT generate_series(1,100);
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                 10000 |           150000 |                 3 | none
+ table_options |                 10000 |           150000 | none        |                 3
 (1 row)
 
 -- test changing the compression
 ALTER TABLE table_options SET (columnar.compression = pglz);
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                 10000 |           150000 |                 3 | pglz
+ table_options |                 10000 |           150000 | pglz        |                 3
 (1 row)
 
 -- test changing the compression level
 ALTER TABLE table_options SET (columnar.compression_level = 5);
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                 10000 |           150000 |                 5 | pglz
+ table_options |                 10000 |           150000 | pglz        |                 5
 (1 row)
 
 -- test changing the chunk_group_row_limit
 ALTER TABLE table_options SET (columnar.chunk_group_row_limit = 2000);
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                  2000 |           150000 |                 5 | pglz
+ table_options |                  2000 |           150000 | pglz        |                 5
 (1 row)
 
 -- test changing the chunk_group_row_limit
 ALTER TABLE table_options SET (columnar.stripe_row_limit = 4000);
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                  2000 |             4000 |                 5 | pglz
+ table_options |                  2000 |             4000 | pglz        |                 5
 (1 row)
 
 -- VACUUM FULL creates a new table, make sure it copies settings from the table you are vacuuming
 VACUUM FULL table_options;
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                  2000 |             4000 |                 5 | pglz
+ table_options |                  2000 |             4000 | pglz        |                 5
 (1 row)
 
 -- set all settings at the same time
@@ -69,49 +69,49 @@ ALTER TABLE table_options SET
    columnar.compression_level = 7);
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                  4000 |             8000 |                 7 | none
+ table_options |                  4000 |             8000 | none        |                 7
 (1 row)
 
 -- make sure table options are not changed when VACUUM a table
 VACUUM table_options;
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                  4000 |             8000 |                 7 | none
+ table_options |                  4000 |             8000 | none        |                 7
 (1 row)
 
 -- make sure table options are not changed when VACUUM FULL a table
 VACUUM FULL table_options;
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                  4000 |             8000 |                 7 | none
+ table_options |                  4000 |             8000 | none        |                 7
 (1 row)
 
 -- make sure table options are not changed when truncating a table
 TRUNCATE table_options;
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                  4000 |             8000 |                 7 | none
+ table_options |                  4000 |             8000 | none        |                 7
 (1 row)
 
 ALTER TABLE table_options ALTER COLUMN a TYPE bigint;
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                  4000 |             8000 |                 7 | none
+ table_options |                  4000 |             8000 | none        |                 7
 (1 row)
 
 -- reset settings one by one to the version of the GUC's
@@ -122,46 +122,46 @@ SET columnar.compression_level TO 11;
 -- verify setting the GUC's didn't change the settings
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                  4000 |             8000 |                 7 | none
+ table_options |                  4000 |             8000 | none        |                 7
 (1 row)
 
 ALTER TABLE table_options RESET (columnar.chunk_group_row_limit);
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                  1000 |             8000 |                 7 | none
+ table_options |                  1000 |             8000 | none        |                 7
 (1 row)
 
 ALTER TABLE table_options RESET (columnar.stripe_row_limit);
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                  1000 |            10000 |                 7 | none
+ table_options |                  1000 |            10000 | none        |                 7
 (1 row)
 
 ALTER TABLE table_options RESET (columnar.compression);
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                  1000 |            10000 |                 7 | pglz
+ table_options |                  1000 |            10000 | pglz        |                 7
 (1 row)
 
 ALTER TABLE table_options RESET (columnar.compression_level);
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                  1000 |            10000 |                11 | pglz
+ table_options |                  1000 |            10000 | pglz        |                11
 (1 row)
 
 -- verify resetting all settings at once work
@@ -171,10 +171,10 @@ SET columnar.compression TO 'none';
 SET columnar.compression_level TO 13;
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                  1000 |            10000 |                11 | pglz
+ table_options |                  1000 |            10000 | pglz        |                11
 (1 row)
 
 ALTER TABLE table_options RESET
@@ -184,10 +184,10 @@ ALTER TABLE table_options RESET
    columnar.compression_level);
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                 10000 |           100000 |                13 | none
+ table_options |                 10000 |           100000 | none        |                13
 (1 row)
 
 -- verify edge cases
@@ -240,10 +240,10 @@ ALTER TABLE table_options
   SET (columnar.compression = pglz, columnar.compression_level = 7),
   SET (columnar.compression_level = 6);
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                 10000 |           100000 |                 6 | pglz
+ table_options |                 10000 |           100000 | pglz        |                 6
 (1 row)
 
 ALTER TABLE table_options
@@ -251,10 +251,10 @@ ALTER TABLE table_options
   RESET (columnar.stripe_row_limit),
   SET (columnar.chunk_group_row_limit = 5555);
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                  5555 |           100000 |                 6 | pglz
+ table_options |                  5555 |           100000 | pglz        |                 6
 (1 row)
 
 -- a no-op; shouldn't throw an error
@@ -271,10 +271,10 @@ SELECT alter_columnar_table_reset('table_options', compression => true);
 
 (1 row)
 
-SELECT * FROM columnar.options WHERE regclass = 'table_options'::regclass;
+SELECT * FROM columnar.options WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                  5555 |           100000 |                 6 | none
+ table_options |                  5555 |           100000 | none        |                 6
 (1 row)
 
 SELECT alter_columnar_table_set('table_options', compression_level => 1);
@@ -283,10 +283,10 @@ SELECT alter_columnar_table_set('table_options', compression_level => 1);
 
 (1 row)
 
-SELECT * FROM columnar.options WHERE regclass = 'table_options'::regclass;
+SELECT * FROM columnar.options WHERE relation = 'table_options'::regclass;
-   regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+   relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- table_options |                  5555 |           100000 |                 1 | none
+ table_options |                  5555 |           100000 | none        |                 1
 (1 row)
 
 -- error: set columnar options on heap tables
@@ -302,8 +302,8 @@ DROP TABLE heap_options;
 -- verify options are removed when table is dropped
 DROP TABLE table_options;
 -- we expect no entries in çstore.options for anything not found int pg_class
-SELECT * FROM columnar.options o WHERE o.regclass NOT IN (SELECT oid FROM pg_class);
+SELECT * FROM columnar.options o WHERE o.relation NOT IN (SELECT oid FROM pg_class);
- regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+ relation | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
 (0 rows)
 

src/test/regress/expected/columnar_test_helpers.out

@@ -1,8 +1,5 @@
 CREATE SCHEMA columnar_test_helpers;
 SET search_path TO columnar_test_helpers;
-CREATE FUNCTION columnar_relation_storageid(relid oid) RETURNS bigint
-    LANGUAGE C STABLE STRICT
-    AS 'citus', $$columnar_relation_storageid$$;
 CREATE OR REPLACE FUNCTION columnar_storage_info(
     rel regclass,
     version_major OUT int4,
@@ -26,22 +23,22 @@ $$ LANGUAGE plpgsql;
 CREATE view chunk_group_consistency AS
 WITH a as (
    SELECT storage_id, stripe_num, chunk_group_num, min(value_count) as row_count
-   FROM columnar.chunk
+   FROM columnar_internal.chunk
    GROUP BY 1,2,3
 ), b as (
    SELECT storage_id, stripe_num, chunk_group_num, max(value_count) as row_count
-   FROM columnar.chunk
+   FROM columnar_internal.chunk
    GROUP BY 1,2,3
 ), c as (
    (TABLE a EXCEPT TABLE b) UNION (TABLE b EXCEPT TABLE a) UNION
-   (TABLE a EXCEPT TABLE columnar.chunk_group) UNION (TABLE columnar.chunk_group EXCEPT TABLE a)
+   (TABLE a EXCEPT TABLE columnar_internal.chunk_group) UNION (TABLE columnar_internal.chunk_group EXCEPT TABLE a)
 ), d as (
    SELECT storage_id, stripe_num, count(*) as chunk_group_count
-   FROM columnar.chunk_group
+   FROM columnar_internal.chunk_group
    GROUP BY 1,2
 ), e as (
    SELECT storage_id, stripe_num, chunk_group_count
-   FROM columnar.stripe
+   FROM columnar_internal.stripe
 ), f as (
    (TABLE d EXCEPT TABLE e) UNION (TABLE e EXCEPT TABLE d)
 )
@@ -54,9 +51,9 @@ DECLARE
 BEGIN
    SELECT count(*) INTO union_storage_id_count FROM
    (
-   SELECT storage_id FROM columnar.stripe UNION ALL
+   SELECT storage_id FROM columnar_internal.stripe UNION ALL
-   SELECT storage_id FROM columnar.chunk UNION ALL
+   SELECT storage_id FROM columnar_internal.chunk UNION ALL
-   SELECT storage_id FROM columnar.chunk_group
+   SELECT storage_id FROM columnar_internal.chunk_group
    ) AS union_storage_id
    WHERE storage_id=input_storage_id;
 

src/test/regress/expected/columnar_truncate.out

@@ -201,7 +201,7 @@ TRUNCATE columnar_same_transaction_truncate;
 INSERT INTO columnar_same_transaction_truncate SELECT * FROM generate_series(20, 23);
 COMMIT;
 -- should output "1" for the newly created relation
-SELECT count(distinct storage_id) - :columnar_data_files_before_truncate FROM columnar.stripe;
+SELECT count(distinct storage_id) - :columnar_data_files_before_truncate FROM columnar_internal.stripe;
  ?column?
 ---------------------------------------------------------------------
         1

src/test/regress/expected/columnar_vacuum.out

@@ -3,7 +3,7 @@ SELECT count(distinct storage_id) AS columnar_table_count FROM columnar.stripe \
 CREATE TABLE t(a int, b int) USING columnar;
 CREATE VIEW t_stripes AS
 SELECT * FROM columnar.stripe a, pg_class b
-WHERE a.storage_id = columnar_test_helpers.columnar_relation_storageid(b.oid) AND b.relname='t';
+WHERE a.storage_id = columnar.get_storage_id(b.oid) AND b.relname='t';
 SELECT count(*) FROM t_stripes;
  count
 ---------------------------------------------------------------------
@@ -107,7 +107,7 @@ SELECT count(*) FROM t_stripes;
 ALTER TABLE t DROP COLUMN a;
 SELECT stripe_num, attr_num, chunk_group_num, minimum_value IS NULL, maximum_value IS NULL
 FROM columnar.chunk a, pg_class b
-WHERE a.storage_id = columnar_test_helpers.columnar_relation_storageid(b.oid) AND b.relname='t' ORDER BY 1, 2, 3;
+WHERE a.storage_id = columnar.get_storage_id(b.oid) AND b.relname='t' ORDER BY 1, 2, 3;
  stripe_num | attr_num | chunk_group_num | ?column? | ?column?
 ---------------------------------------------------------------------
           1 |        1 |               0 | f        | f
@@ -121,7 +121,7 @@ WHERE a.storage_id = columnar_test_helpers.columnar_relation_storageid(b.oid) AN
 VACUUM FULL t;
 SELECT stripe_num, attr_num, chunk_group_num, minimum_value IS NULL, maximum_value IS NULL
 FROM columnar.chunk a, pg_class b
-WHERE a.storage_id = columnar_test_helpers.columnar_relation_storageid(b.oid) AND b.relname='t' ORDER BY 1, 2, 3;
+WHERE a.storage_id = columnar.get_storage_id(b.oid) AND b.relname='t' ORDER BY 1, 2, 3;
  stripe_num | attr_num | chunk_group_num | ?column? | ?column?
 ---------------------------------------------------------------------
           1 |        1 |               0 | t        | t

src/test/regress/expected/multi_extension.out

@@ -94,7 +94,7 @@ FROM pg_depend AS pgd,
 WHERE pgd.refclassid = 'pg_extension'::regclass AND
 	  pgd.refobjid   = pge.oid AND
 	  pge.extname    = 'citus' AND
-	  pgio.schema    NOT IN ('pg_catalog', 'citus', 'citus_internal', 'test', 'columnar')
+	  pgio.schema    NOT IN ('pg_catalog', 'citus', 'citus_internal', 'test', 'columnar', 'columnar_internal')
 ORDER BY 1, 2;
  type |      identity
 ---------------------------------------------------------------------
@@ -1053,6 +1053,7 @@ ALTER EXTENSION citus UPDATE TO '11.1-1';
 SELECT * FROM multi_extension.print_extension_changes();
                                     previous_object                                     |                             current_object
 ---------------------------------------------------------------------
+ function columnar.columnar_handler(internal) table_am_handler                          |
  function worker_cleanup_job_schema_cache() void                                        |
  function worker_create_schema(bigint,text) void                                        |
  function worker_fetch_foreign_file(text,text,bigint,text[],integer[]) void             |
@@ -1061,7 +1062,25 @@ SELECT * FROM multi_extension.print_extension_changes();
  function worker_merge_files_into_table(bigint,integer,text[],text[]) void              |
  function worker_range_partition_table(bigint,integer,text,text,oid,anyarray) void      |
  function worker_repartition_cleanup(bigint) void                                       |
-(8 rows)
+ sequence columnar.storageid_seq                                                        |
+ table columnar.chunk                                                                   |
+ table columnar.chunk_group                                                             |
+ table columnar.options                                                                 |
+ table columnar.stripe                                                                  |
+                                                                                        | function columnar.get_storage_id(regclass) bigint
+                                                                                        | function columnar_internal.columnar_handler(internal) table_am_handler
+                                                                                        | schema columnar_internal
+                                                                                        | sequence columnar_internal.storageid_seq
+                                                                                        | table columnar_internal.chunk
+                                                                                        | table columnar_internal.chunk_group
+                                                                                        | table columnar_internal.options
+                                                                                        | table columnar_internal.stripe
+                                                                                        | view columnar.chunk
+                                                                                        | view columnar.chunk_group
+                                                                                        | view columnar.options
+                                                                                        | view columnar.storage
+                                                                                        | view columnar.stripe
+(27 rows)
 
 -- Test downgrade script (result should be empty)
 ALTER EXTENSION citus UPDATE TO '11.0-2';
@@ -1087,7 +1106,7 @@ FROM pg_depend AS pgd,
 WHERE pgd.refclassid = 'pg_extension'::regclass AND
 	  pgd.refobjid   = pge.oid AND
 	  pge.extname    = 'citus' AND
-	  pgio.schema    NOT IN ('pg_catalog', 'citus', 'citus_internal', 'test', 'columnar')
+	  pgio.schema    NOT IN ('pg_catalog', 'citus', 'citus_internal', 'test', 'columnar', 'columnar_internal')
 ORDER BY 1, 2;
  type |      identity
 ---------------------------------------------------------------------

src/test/regress/expected/multi_multiuser.out

@@ -231,7 +231,7 @@ ABORT;
 -- all below 5 commands should throw no permission errors
 -- read columnar metadata table
 SELECT * FROM columnar.stripe;
- storage_id | stripe_num | file_offset | data_length | column_count | chunk_row_count | row_count | chunk_group_count | first_row_number
+ relation | storage_id | stripe_num | file_offset | data_length | column_count | chunk_row_count | row_count | chunk_group_count | first_row_number
 ---------------------------------------------------------------------
 (0 rows)
 
@@ -261,16 +261,18 @@ SET ROLE read_access;
 -- and drop it
 DROP TABLE columnar_table;
 -- cannot modify columnar metadata table as unprivileged user
-INSERT INTO columnar.stripe VALUES(99);
+INSERT INTO columnar_internal.stripe VALUES(99);
-ERROR:  permission denied for table stripe
+ERROR:  permission denied for schema columnar_internal
 -- Cannot drop columnar metadata table as unprivileged user.
 -- Privileged user also cannot drop but with a different error message.
 -- (since citus extension has a dependency to it)
-DROP TABLE columnar.chunk;
+DROP TABLE columnar_internal.chunk;
-ERROR:  must be owner of table chunk
+ERROR:  permission denied for schema columnar_internal
--- cannot read columnar.chunk since it could expose chunk min/max values
 SELECT * FROM columnar.chunk;
-ERROR:  permission denied for table chunk
+ relation | storage_id | stripe_num | attr_num | chunk_group_num | minimum_value | maximum_value | value_stream_offset | value_stream_length | exists_stream_offset | exists_stream_length | value_compression_type | value_compression_level | value_decompressed_length | value_count
+---------------------------------------------------------------------
+(0 rows)
+
 -- test whether a read-only user can read from citus_tables view
 SELECT distribution_column FROM citus_tables WHERE table_name = 'test'::regclass;
  distribution_column

src/test/regress/expected/upgrade_columnar_after.out

@@ -101,10 +101,10 @@ SELECT * FROM matview ORDER BY a;
 (2 rows)
 
 -- test we retained options
-SELECT * FROM columnar.options WHERE regclass = 'test_options_1'::regclass;
+SELECT * FROM columnar.options WHERE relation = 'test_options_1'::regclass;
-    regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+    relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- test_options_1 |                  1000 |             5000 |                 3 | pglz
+ test_options_1 |                  1000 |             5000 | pglz        |                 3
 (1 row)
 
 VACUUM VERBOSE test_options_1;
@@ -121,10 +121,10 @@ SELECT count(*), sum(a), sum(b) FROM test_options_1;
  10000 | 50005000 | 45010
 (1 row)
 
-SELECT * FROM columnar.options WHERE regclass = 'test_options_2'::regclass;
+SELECT * FROM columnar.options WHERE relation = 'test_options_2'::regclass;
-    regclass    | chunk_group_row_limit | stripe_row_limit | compression_level | compression
+    relation    | chunk_group_row_limit | stripe_row_limit | compression | compression_level
 ---------------------------------------------------------------------
- test_options_2 |                  2000 |             6000 |                13 | none
+ test_options_2 |                  2000 |             6000 | none        |                13
 (1 row)
 
 VACUUM VERBOSE test_options_2;
@@ -272,7 +272,7 @@ ROLLBACK;
 SELECT pg_class.oid INTO columnar_schema_members
 FROM pg_class, pg_namespace
 WHERE pg_namespace.oid=pg_class.relnamespace AND
-      pg_namespace.nspname='columnar';
+      pg_namespace.nspname='columnar_internal';
 SELECT refobjid INTO columnar_schema_members_pg_depend
 FROM pg_depend
 WHERE classid = 'pg_am'::regclass::oid AND
@@ -304,7 +304,7 @@ $$
 SELECT pg_class.oid INTO columnar_schema_members
 FROM pg_class, pg_namespace
 WHERE pg_namespace.oid=pg_class.relnamespace AND
-	  pg_namespace.nspname='columnar';
+	  pg_namespace.nspname='columnar_internal';
 SELECT refobjid INTO columnar_schema_members_pg_depend
 FROM pg_depend
 WHERE classid = 'pg_am'::regclass::oid AND

src/test/regress/expected/upgrade_list_citus_objects.out

@@ -128,7 +128,8 @@ ORDER BY 1;
  function citus_version()
  function column_name_to_column(regclass,text)
  function column_to_column_name(regclass,text)
- function columnar.columnar_handler(internal)
+ function columnar.get_storage_id(regclass)
+ function columnar_internal.columnar_handler(internal)
  function coord_combine_agg(oid,cstring,anyelement)
  function coord_combine_agg_ffunc(internal,oid,cstring,anyelement)
  function coord_combine_agg_sfunc(internal,oid,cstring,anyelement)
@@ -241,16 +242,17 @@ ORDER BY 1;
  schema citus
  schema citus_internal
  schema columnar
- sequence columnar.storageid_seq
+ schema columnar_internal
+ sequence columnar_internal.storageid_seq
  sequence pg_dist_colocationid_seq
  sequence pg_dist_groupid_seq
  sequence pg_dist_node_nodeid_seq
  sequence pg_dist_placement_placementid_seq
  sequence pg_dist_shardid_seq
- table columnar.chunk
+ table columnar_internal.chunk
- table columnar.chunk_group
+ table columnar_internal.chunk_group
- table columnar.options
+ table columnar_internal.options
- table columnar.stripe
+ table columnar_internal.stripe
  table pg_dist_authinfo
  table pg_dist_colocation
  table pg_dist_local_group
@@ -275,7 +277,12 @@ ORDER BY 1;
  view citus_shards_on_worker
  view citus_stat_activity
  view citus_stat_statements
+ view columnar.chunk
+ view columnar.chunk_group
+ view columnar.options
+ view columnar.storage
+ view columnar.stripe
  view pg_dist_shard_placement
  view time_partitions
-(261 rows)
+(268 rows)
 

src/test/regress/sql/columnar_citus_integration.sql

@@ -21,73 +21,73 @@ SELECT create_distributed_table('table_option', 'a');
 -- setting: compression
 -- get baseline for setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- change setting
 ALTER TABLE table_option SET (columnar.compression = pglz);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- reset setting
 ALTER TABLE table_option RESET (columnar.compression);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- setting: compression_level
 -- get baseline for setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- change setting
 ALTER TABLE table_option SET (columnar.compression_level = 13);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- reset setting
 ALTER TABLE table_option RESET (columnar.compression_level);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- setting: chunk_group_row_limit
 -- get baseline for setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- change setting
 ALTER TABLE table_option SET (columnar.chunk_group_row_limit = 2000);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- reset setting
 ALTER TABLE table_option RESET (columnar.chunk_group_row_limit);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- setting: stripe_row_limit
 -- get baseline for setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- change setting
 ALTER TABLE table_option SET (columnar.stripe_row_limit = 2000);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- reset setting
 ALTER TABLE table_option RESET (columnar.stripe_row_limit);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- verify settings are propagated when creating a table
@@ -101,13 +101,13 @@ SELECT create_distributed_table('table_option_2', 'a');
 
 -- verify settings on placements
 SELECT run_command_on_placements('table_option_2',$cmd$
-  SELECT ROW(chunk_group_row_limit, stripe_row_limit, compression, compression_level) FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT ROW(chunk_group_row_limit, stripe_row_limit, compression, compression_level) FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- verify undistribute works
 SELECT undistribute_table('table_option');
 SELECT * FROM pg_dist_partition WHERE logicalrelid = 'table_option'::regclass;
-SELECT compression FROM columnar.options WHERE regclass = 'table_option'::regclass;
+SELECT compression FROM columnar.options WHERE relation = 'table_option'::regclass;
 
 DROP TABLE table_option, table_option_2;
 
@@ -121,73 +121,73 @@ SELECT create_distributed_table('table_option', 'a');
 -- setting: compression
 -- get baseline for setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- change setting
 ALTER TABLE table_option SET (columnar.compression = pglz);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- reset setting
 ALTER TABLE table_option RESET (columnar.compression);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- setting: compression_level
 -- get baseline for setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- change setting
 ALTER TABLE table_option SET (columnar.compression_level = 17);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- reset setting
 ALTER TABLE table_option RESET (columnar.compression_level);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- setting: chunk_group_row_limit
 -- get baseline for setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- change setting
 ALTER TABLE table_option SET (columnar.chunk_group_row_limit = 2000);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- reset setting
 ALTER TABLE table_option RESET (columnar.chunk_group_row_limit);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- setting: stripe_row_limit
 -- get baseline for setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- change setting
 ALTER TABLE table_option SET (columnar.stripe_row_limit = 2000);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- reset setting
 ALTER TABLE table_option RESET (columnar.stripe_row_limit);
 -- verify setting
 SELECT run_command_on_placements('table_option',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- verify settings are propagated when creating a table
@@ -201,13 +201,13 @@ SELECT create_distributed_table('table_option_2', 'a');
 
 -- verify settings on placements
 SELECT run_command_on_placements('table_option_2',$cmd$
-  SELECT ROW(chunk_group_row_limit, stripe_row_limit, compression, compression_level) FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT ROW(chunk_group_row_limit, stripe_row_limit, compression, compression_level) FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- verify undistribute works
 SELECT undistribute_table('table_option');
 SELECT * FROM pg_dist_partition WHERE logicalrelid = 'table_option'::regclass;
-SELECT compression FROM columnar.options WHERE regclass = 'table_option'::regclass;
+SELECT compression FROM columnar.options WHERE relation = 'table_option'::regclass;
 
 DROP TABLE table_option, table_option_2;
 
@@ -218,73 +218,73 @@ SELECT create_reference_table('table_option_reference');
 -- setting: compression
 -- get baseline for setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- change setting
 ALTER TABLE table_option_reference SET (columnar.compression = pglz);
 -- verify setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- reset setting
 ALTER TABLE table_option_reference RESET (columnar.compression);
 -- verify setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- setting: compression_level
 -- get baseline for setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- change setting
 ALTER TABLE table_option_reference SET (columnar.compression_level = 11);
 -- verify setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- reset setting
 ALTER TABLE table_option_reference RESET (columnar.compression_level);
 -- verify setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- setting: chunk_group_row_limit
 -- get baseline for setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- change setting
 ALTER TABLE table_option_reference SET (columnar.chunk_group_row_limit = 2000);
 -- verify setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- reset setting
 ALTER TABLE table_option_reference RESET (columnar.chunk_group_row_limit);
 -- verify setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- setting: stripe_row_limit
 -- get baseline for setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- change setting
 ALTER TABLE table_option_reference SET (columnar.stripe_row_limit = 2000);
 -- verify setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- reset setting
 ALTER TABLE table_option_reference RESET (columnar.stripe_row_limit);
 -- verify setting
 SELECT run_command_on_placements('table_option_reference',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- verify settings are propagated when creating a table
@@ -298,13 +298,13 @@ SELECT create_reference_table('table_option_reference_2');
 
 -- verify settings on placements
 SELECT run_command_on_placements('table_option_reference_2',$cmd$
-  SELECT ROW(chunk_group_row_limit, stripe_row_limit, compression, compression_level) FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT ROW(chunk_group_row_limit, stripe_row_limit, compression, compression_level) FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- verify undistribute works
 SELECT undistribute_table('table_option_reference');
 SELECT * FROM pg_dist_partition WHERE logicalrelid = 'table_option_reference'::regclass;
-SELECT compression FROM columnar.options WHERE regclass = 'table_option_reference'::regclass;
+SELECT compression FROM columnar.options WHERE relation = 'table_option_reference'::regclass;
 
 DROP TABLE table_option_reference, table_option_reference_2;
 
@@ -318,73 +318,73 @@ SELECT citus_add_local_table_to_metadata('table_option_citus_local');
 -- setting: compression
 -- get baseline for setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- change setting
 ALTER TABLE table_option_citus_local SET (columnar.compression = pglz);
 -- verify setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- reset setting
 ALTER TABLE table_option_citus_local RESET (columnar.compression);
 -- verify setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT compression FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- setting: compression_level
 -- get baseline for setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- change setting
 ALTER TABLE table_option_citus_local SET (columnar.compression_level = 11);
 -- verify setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- reset setting
 ALTER TABLE table_option_citus_local RESET (columnar.compression_level);
 -- verify setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT compression_level FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT compression_level FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- setting: chunk_group_row_limit
 -- get baseline for setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- change setting
 ALTER TABLE table_option_citus_local SET (columnar.chunk_group_row_limit = 2000);
 -- verify setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- reset setting
 ALTER TABLE table_option_citus_local RESET (columnar.chunk_group_row_limit);
 -- verify setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT chunk_group_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT chunk_group_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- setting: stripe_row_limit
 -- get baseline for setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- change setting
 ALTER TABLE table_option_citus_local SET (columnar.stripe_row_limit = 2000);
 -- verify setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 -- reset setting
 ALTER TABLE table_option_citus_local RESET (columnar.stripe_row_limit);
 -- verify setting
 SELECT run_command_on_placements('table_option_citus_local',$cmd$
-  SELECT stripe_row_limit FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT stripe_row_limit FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- verify settings are propagated when creating a table
@@ -398,13 +398,13 @@ SELECT citus_add_local_table_to_metadata('table_option_citus_local_2');
 
 -- verify settings on placements
 SELECT run_command_on_placements('table_option_citus_local_2',$cmd$
-  SELECT ROW(chunk_group_row_limit, stripe_row_limit, compression, compression_level) FROM columnar.options WHERE regclass = '%s'::regclass;
+  SELECT ROW(chunk_group_row_limit, stripe_row_limit, compression, compression_level) FROM columnar.options WHERE relation = '%s'::regclass;
 $cmd$);
 
 -- verify undistribute works
 SELECT undistribute_table('table_option_citus_local');
 SELECT * FROM pg_dist_partition WHERE logicalrelid = 'table_option_citus_local'::regclass;
-SELECT compression FROM columnar.options WHERE regclass = 'table_option_citus_local'::regclass;
+SELECT compression FROM columnar.options WHERE relation = 'table_option_citus_local'::regclass;
 
 DROP TABLE table_option_citus_local, table_option_citus_local_2;
 SELECT 1 FROM master_remove_node('localhost', :master_port);

src/test/regress/sql/columnar_create.sql

@@ -29,14 +29,14 @@ INSERT INTO columnar_table_1 VALUES (1);
 CREATE MATERIALIZED VIEW columnar_table_1_mv USING columnar
 AS SELECT * FROM columnar_table_1;
 
-SELECT columnar_test_helpers.columnar_relation_storageid(oid) AS columnar_table_1_mv_storage_id
+SELECT columnar.get_storage_id(oid) AS columnar_table_1_mv_storage_id
 FROM pg_class WHERE relname='columnar_table_1_mv' \gset
 
 -- test columnar_relation_set_new_filenode
 REFRESH MATERIALIZED VIEW columnar_table_1_mv;
 SELECT columnar_test_helpers.columnar_metadata_has_storage_id(:columnar_table_1_mv_storage_id);
 
-SELECT columnar_test_helpers.columnar_relation_storageid(oid) AS columnar_table_1_storage_id
+SELECT columnar.get_storage_id(oid) AS columnar_table_1_storage_id
 FROM pg_class WHERE relname='columnar_table_1' \gset
 
 BEGIN;
@@ -60,7 +60,7 @@ CREATE TEMPORARY TABLE columnar_temp(i int) USING columnar;
 -- reserve some chunks and a stripe
 INSERT INTO columnar_temp SELECT i FROM generate_series(1,5) i;
 
-SELECT columnar_test_helpers.columnar_relation_storageid(oid) AS columnar_temp_storage_id
+SELECT columnar.get_storage_id(oid) AS columnar_temp_storage_id
 FROM pg_class WHERE relname='columnar_temp' \gset
 
 SELECT pg_backend_pid() AS val INTO old_backend_pid;
@@ -85,7 +85,7 @@ INSERT INTO columnar_temp SELECT i FROM generate_series(1,5) i;
 -- test basic select
 SELECT COUNT(*) FROM columnar_temp WHERE i < 5;
 
-SELECT columnar_test_helpers.columnar_relation_storageid(oid) AS columnar_temp_storage_id
+SELECT columnar.get_storage_id(oid) AS columnar_temp_storage_id
 FROM pg_class WHERE relname='columnar_temp' \gset
 
 BEGIN;
@@ -107,7 +107,7 @@ BEGIN;
   -- force flushing stripe
   INSERT INTO columnar_temp SELECT i FROM generate_series(1,150000) i;
 
-  SELECT columnar_test_helpers.columnar_relation_storageid(oid) AS columnar_temp_storage_id
+  SELECT columnar.get_storage_id(oid) AS columnar_temp_storage_id
   FROM pg_class WHERE relname='columnar_temp' \gset
 COMMIT;
 
@@ -120,7 +120,7 @@ BEGIN;
   -- force flushing stripe
   INSERT INTO columnar_temp SELECT i FROM generate_series(1,150000) i;
 
-  SELECT columnar_test_helpers.columnar_relation_storageid(oid) AS columnar_temp_storage_id
+  SELECT columnar.get_storage_id(oid) AS columnar_temp_storage_id
   FROM pg_class WHERE relname='columnar_temp' \gset
 COMMIT;
 

src/test/regress/sql/columnar_empty.sql

@@ -11,7 +11,7 @@ ALTER TABLE t_compressed SET (columnar.compression = pglz);
 ALTER TABLE t_compressed SET (columnar.stripe_row_limit = 2000);
 ALTER TABLE t_compressed SET (columnar.chunk_group_row_limit = 1000);
 
-SELECT * FROM columnar.options WHERE regclass = 't_compressed'::regclass;
+SELECT * FROM columnar.options WHERE relation = 't_compressed'::regclass;
 
 -- select
 select * from t_uncompressed;

src/test/regress/sql/columnar_first_row_number.sql

@@ -17,14 +17,14 @@ ALTER TABLE col_table_1 SET (columnar.stripe_row_limit = 1000);
 INSERT INTO col_table_1 SELECT i FROM generate_series(1, 2350) i;
 
 SELECT row_count, first_row_number FROM columnar.stripe a
-WHERE a.storage_id = columnar_test_helpers.columnar_relation_storageid('col_table_1'::regclass)
+WHERE a.storage_id = columnar.get_storage_id('col_table_1'::regclass)
 ORDER BY stripe_num;
 
 VACUUM FULL col_table_1;
 
 -- show that we properly update first_row_number after VACUUM FULL
 SELECT row_count, first_row_number FROM columnar.stripe a
-WHERE a.storage_id = columnar_test_helpers.columnar_relation_storageid('col_table_1'::regclass)
+WHERE a.storage_id = columnar.get_storage_id('col_table_1'::regclass)
 ORDER BY stripe_num;
 
 TRUNCATE col_table_1;
@@ -36,7 +36,7 @@ COMMIT;
 
 -- show that we start with first_row_number=1 after TRUNCATE
 SELECT row_count, first_row_number FROM columnar.stripe a
-WHERE a.storage_id = columnar_test_helpers.columnar_relation_storageid('col_table_1'::regclass)
+WHERE a.storage_id = columnar.get_storage_id('col_table_1'::regclass)
 ORDER BY stripe_num;
 
 SET client_min_messages TO ERROR;

src/test/regress/sql/columnar_indexes.sql

@@ -407,12 +407,12 @@ INSERT INTO aborted_write_test VALUES (16999);
 REINDEX TABLE aborted_write_test;
 
 BEGIN;
-  ALTER TABLE columnar.stripe SET (autovacuum_enabled = false);
+  ALTER TABLE columnar_internal.stripe SET (autovacuum_enabled = false);
-  ALTER TABLE columnar.chunk SET (autovacuum_enabled = false);
+  ALTER TABLE columnar_internal.chunk SET (autovacuum_enabled = false);
-  ALTER TABLE columnar.chunk_group SET (autovacuum_enabled = false);
+  ALTER TABLE columnar_internal.chunk_group SET (autovacuum_enabled = false);
 
   DROP TABLE aborted_write_test;
-  TRUNCATE columnar.stripe, columnar.chunk, columnar.chunk_group;
+  TRUNCATE columnar_internal.stripe, columnar_internal.chunk, columnar_internal.chunk_group;
 
   CREATE TABLE aborted_write_test (a INT) USING columnar;
 
@@ -422,12 +422,13 @@ BEGIN;
     SELECT FROM aborted_write_test;
   ROLLBACK TO SAVEPOINT svpt;
 
-  -- Already disabled autovacuum for all three metadata tables.
+  -- Already disabled autovacuum for all three metadata tables.  Here
-  -- Here we truncate columnar.chunk and columnar.chunk_group but not
+  -- we truncate columnar_internal.chunk and
-  -- columnar.stripe to make sure that we properly handle dead tuples
+  -- columnar.chunk_group but not columnar.stripe to
-  -- in columnar.stripe, i.e. stripe metadata entries for aborted
+  -- make sure that we properly handle dead tuples in
-  -- transactions.
+  -- columnar.stripe, i.e. stripe metadata entries for
-  TRUNCATE columnar.chunk, columnar.chunk_group;
+  -- aborted transactions.
+  TRUNCATE columnar_internal.chunk, columnar_internal.chunk_group;
 
   CREATE INDEX ON aborted_write_test (a);
 ROLLBACK;
@@ -477,7 +478,7 @@ rollback;
 insert into uniq select generate_series(1,100);
 
 SELECT COUNT(*)=1 FROM columnar.stripe cs
-WHERE cs.storage_id = columnar_test_helpers.columnar_relation_storageid('columnar_indexes.uniq'::regclass);
+WHERE cs.storage_id = columnar.get_storage_id('columnar_indexes.uniq'::regclass);
 
 TRUNCATE uniq;
 
@@ -489,7 +490,7 @@ rollback;
 insert into uniq select generate_series(1,100);
 
 SELECT COUNT(*)=1 FROM columnar.stripe cs
-WHERE cs.storage_id = columnar_test_helpers.columnar_relation_storageid('columnar_indexes.uniq'::regclass);
+WHERE cs.storage_id = columnar.get_storage_id('columnar_indexes.uniq'::regclass);
 
 TRUNCATE uniq;
 
@@ -501,7 +502,7 @@ rollback;
 insert into uniq select generate_series(1,100);
 
 SELECT COUNT(*)=1 FROM columnar.stripe cs
-WHERE cs.storage_id = columnar_test_helpers.columnar_relation_storageid('columnar_indexes.uniq'::regclass);
+WHERE cs.storage_id = columnar.get_storage_id('columnar_indexes.uniq'::regclass);
 
 TRUNCATE uniq;
 
@@ -513,7 +514,7 @@ rollback;
 insert into uniq select generate_series(1,100);
 
 SELECT COUNT(*)=1 FROM columnar.stripe cs
-WHERE cs.storage_id = columnar_test_helpers.columnar_relation_storageid('columnar_indexes.uniq'::regclass);
+WHERE cs.storage_id = columnar.get_storage_id('columnar_indexes.uniq'::regclass);
 
 TRUNCATE uniq;
 
@@ -529,12 +530,12 @@ begin;
 
   -- didn't flush anything yet, but should see the in progress stripe-write
   SELECT stripe_num, first_row_number, row_count FROM columnar.stripe cs
-  WHERE cs.storage_id = columnar_test_helpers.columnar_relation_storageid('columnar_indexes.uniq'::regclass);
+  WHERE cs.storage_id = columnar.get_storage_id('columnar_indexes.uniq'::regclass);
 commit;
 
 -- should have completed the stripe reservation
 SELECT stripe_num, first_row_number, row_count FROM columnar.stripe cs
-WHERE cs.storage_id = columnar_test_helpers.columnar_relation_storageid('columnar_indexes.uniq'::regclass);
+WHERE cs.storage_id = columnar.get_storage_id('columnar_indexes.uniq'::regclass);
 
 TRUNCATE uniq;
 

src/test/regress/sql/columnar_insert.sql

@@ -144,15 +144,15 @@ select
   from columnar_test_helpers.columnar_storage_info('zero_col');
 
 SELECT relname, stripe_num, chunk_group_count, row_count FROM columnar.stripe a, pg_class b
-WHERE columnar_test_helpers.columnar_relation_storageid(b.oid)=a.storage_id AND relname = 'zero_col'
+WHERE columnar.get_storage_id(b.oid)=a.storage_id AND relname = 'zero_col'
 ORDER BY 1,2,3,4;
 
 SELECT relname, stripe_num, value_count FROM columnar.chunk a, pg_class b
-WHERE columnar_test_helpers.columnar_relation_storageid(b.oid)=a.storage_id AND relname = 'zero_col'
+WHERE columnar.get_storage_id(b.oid)=a.storage_id AND relname = 'zero_col'
 ORDER BY 1,2,3;
 
 SELECT relname, stripe_num, chunk_group_num, row_count FROM columnar.chunk_group a, pg_class b
-WHERE columnar_test_helpers.columnar_relation_storageid(b.oid)=a.storage_id AND relname = 'zero_col'
+WHERE columnar.get_storage_id(b.oid)=a.storage_id AND relname = 'zero_col'
 ORDER BY 1,2,3,4;
 
 CREATE TABLE selfinsert(x int) USING columnar;

src/test/regress/sql/columnar_matview.sql

@@ -19,23 +19,23 @@ SELECT * FROM t_view a ORDER BY a;
 
 -- show columnar options for materialized view
 SELECT * FROM columnar.options
-WHERE regclass = 't_view'::regclass;
+WHERE relation = 't_view'::regclass;
 
 -- show we can set options on a materialized view
 ALTER TABLE t_view SET (columnar.compression = pglz);
 SELECT * FROM columnar.options
-WHERE regclass = 't_view'::regclass;
+WHERE relation = 't_view'::regclass;
 
 REFRESH MATERIALIZED VIEW t_view;
 
 -- verify options have not been changed
 SELECT * FROM columnar.options
-WHERE regclass = 't_view'::regclass;
+WHERE relation = 't_view'::regclass;
 
 SELECT * FROM t_view a ORDER BY a;
 
 -- verify that we have created metadata entries for the materialized view
-SELECT columnar_test_helpers.columnar_relation_storageid(oid) AS storageid
+SELECT columnar.get_storage_id(oid) AS storageid
 FROM pg_class WHERE relname='t_view' \gset
 
 SELECT count(*) FROM columnar.stripe WHERE storage_id=:storageid;

src/test/regress/sql/columnar_permissions.sql

@@ -1,29 +1,75 @@
 
 create table no_access (i int) using columnar;
 
+insert into no_access values(1);
+insert into no_access values(2);
+insert into no_access values(3);
+
 select current_user \gset
 
 create user columnar_user;
 
 \c - columnar_user
 
+-- owned by columnar_user
 create table columnar_permissions(i int) using columnar;
 insert into columnar_permissions values(1);
+insert into columnar_permissions values(2);
 alter table columnar_permissions add column j int;
 alter table columnar_permissions reset (columnar.compression);
 alter table columnar_permissions set (columnar.compression = none);
 select alter_columnar_table_reset('columnar_permissions', stripe_row_limit => true);
 select alter_columnar_table_set('columnar_permissions', stripe_row_limit => 2222);
-select * from columnar.options where regclass = 'columnar_permissions'::regclass;
-insert into columnar_permissions values(2,20);
-vacuum columnar_permissions;
-truncate columnar_permissions;
-drop table columnar_permissions;
 
--- should error
+select 1 from columnar.get_storage_id('columnar_permissions'::regclass);
+
+-- error
+select 1 from columnar.get_storage_id('no_access'::regclass);
+
+-- only tuples related to columnar_permissions should be visible
+select relation, chunk_group_row_limit, stripe_row_limit, compression, compression_level
+  from columnar.options
+  where relation in ('no_access'::regclass, 'columnar_permissions'::regclass);
+select relation, stripe_num, row_count, first_row_number
+  from columnar.stripe
+  where relation in ('no_access'::regclass, 'columnar_permissions'::regclass);
+select relation, stripe_num, attr_num, chunk_group_num, value_count
+  from columnar.chunk
+  where relation in ('no_access'::regclass, 'columnar_permissions'::regclass);
+select relation, stripe_num, chunk_group_num, row_count
+  from columnar.chunk_group
+  where relation in ('no_access'::regclass, 'columnar_permissions'::regclass);
+
+truncate columnar_permissions;
+
+insert into columnar_permissions values(2,20);
+insert into columnar_permissions values(2,30);
+insert into columnar_permissions values(4,40);
+insert into columnar_permissions values(5,50);
+
+vacuum columnar_permissions;
+
+-- error: columnar_user can't alter no_access
 alter table no_access reset (columnar.stripe_row_limit);
 alter table no_access set (columnar.stripe_row_limit = 12000);
 select alter_columnar_table_reset('no_access', chunk_group_row_limit => true);
 select alter_columnar_table_set('no_access', chunk_group_row_limit => 1111);
 
 \c - :current_user
+
+-- should see tuples from both columnar_permissions and no_access
+select relation, chunk_group_row_limit, stripe_row_limit, compression, compression_level
+  from columnar.options
+  where relation in ('no_access'::regclass, 'columnar_permissions'::regclass);
+select relation, stripe_num, row_count, first_row_number
+  from columnar.stripe
+  where relation in ('no_access'::regclass, 'columnar_permissions'::regclass);
+select relation, stripe_num, attr_num, chunk_group_num, value_count
+  from columnar.chunk
+  where relation in ('no_access'::regclass, 'columnar_permissions'::regclass);
+select relation, stripe_num, chunk_group_num, row_count
+  from columnar.chunk_group
+  where relation in ('no_access'::regclass, 'columnar_permissions'::regclass);
+
+drop table columnar_permissions;
+drop table no_access;

src/test/regress/sql/columnar_recursive.sql

@@ -16,7 +16,7 @@ INSERT INTO t2 SELECT i, f(i) FROM generate_series(1, 5) i;
 -- there are no subtransactions, so above statement should batch
 -- INSERTs inside the UDF and create on stripe per table.
 SELECT relname, count(*) FROM columnar.stripe a, pg_class b
-WHERE columnar_test_helpers.columnar_relation_storageid(b.oid)=a.storage_id AND relname IN ('t1', 't2')
+WHERE columnar.get_storage_id(b.oid)=a.storage_id AND relname IN ('t1', 't2')
 GROUP BY relname
 ORDER BY relname;
 

src/test/regress/sql/columnar_rollback.sql

@@ -6,7 +6,7 @@ CREATE TABLE t(a int, b int) USING columnar;
 
 CREATE VIEW t_stripes AS
 SELECT * FROM columnar.stripe a, pg_class b
-WHERE a.storage_id = columnar_test_helpers.columnar_relation_storageid(b.oid) AND b.relname = 't';
+WHERE a.storage_id = columnar.get_storage_id(b.oid) AND b.relname = 't';
 
 BEGIN;
 INSERT INTO t SELECT i, i+1 FROM generate_series(1, 10) i;

src/test/regress/sql/columnar_tableoptions.sql

@@ -7,42 +7,42 @@ INSERT INTO table_options SELECT generate_series(1,100);
 
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 -- test changing the compression
 ALTER TABLE table_options SET (columnar.compression = pglz);
 
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 -- test changing the compression level
 ALTER TABLE table_options SET (columnar.compression_level = 5);
 
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 -- test changing the chunk_group_row_limit
 ALTER TABLE table_options SET (columnar.chunk_group_row_limit = 2000);
 
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 -- test changing the chunk_group_row_limit
 ALTER TABLE table_options SET (columnar.stripe_row_limit = 4000);
 
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 -- VACUUM FULL creates a new table, make sure it copies settings from the table you are vacuuming
 VACUUM FULL table_options;
 
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 -- set all settings at the same time
 ALTER TABLE table_options SET
@@ -53,30 +53,30 @@ ALTER TABLE table_options SET
 
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 -- make sure table options are not changed when VACUUM a table
 VACUUM table_options;
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 -- make sure table options are not changed when VACUUM FULL a table
 VACUUM FULL table_options;
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 -- make sure table options are not changed when truncating a table
 TRUNCATE table_options;
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 ALTER TABLE table_options ALTER COLUMN a TYPE bigint;
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 -- reset settings one by one to the version of the GUC's
 SET columnar.chunk_group_row_limit TO 1000;
@@ -87,30 +87,30 @@ SET columnar.compression_level TO 11;
 -- verify setting the GUC's didn't change the settings
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 ALTER TABLE table_options RESET (columnar.chunk_group_row_limit);
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 ALTER TABLE table_options RESET (columnar.stripe_row_limit);
 
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 ALTER TABLE table_options RESET (columnar.compression);
 
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 ALTER TABLE table_options RESET (columnar.compression_level);
 
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 -- verify resetting all settings at once work
 SET columnar.chunk_group_row_limit TO 10000;
@@ -120,7 +120,7 @@ SET columnar.compression_level TO 13;
 
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 ALTER TABLE table_options RESET
   (columnar.chunk_group_row_limit,
@@ -130,7 +130,7 @@ ALTER TABLE table_options RESET
 
 -- show table_options settings
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 -- verify edge cases
 -- first start with a table that is not a columnar table
@@ -168,7 +168,7 @@ ALTER TABLE table_options
   SET (columnar.compression_level = 6);
 
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 ALTER TABLE table_options
   SET (columnar.compression = pglz, columnar.stripe_row_limit = 7777),
@@ -176,7 +176,7 @@ ALTER TABLE table_options
   SET (columnar.chunk_group_row_limit = 5555);
 
 SELECT * FROM columnar.options
-WHERE regclass = 'table_options'::regclass;
+WHERE relation = 'table_options'::regclass;
 
 -- a no-op; shouldn't throw an error
 ALTER TABLE IF EXISTS what SET (columnar.compression = lz4);
@@ -187,9 +187,9 @@ CREATE TABLE IF NOT EXISTS table_options(a int) USING columnar
 
 -- test old interface based on functions
 SELECT alter_columnar_table_reset('table_options', compression => true);
-SELECT * FROM columnar.options WHERE regclass = 'table_options'::regclass;
+SELECT * FROM columnar.options WHERE relation = 'table_options'::regclass;
 SELECT alter_columnar_table_set('table_options', compression_level => 1);
-SELECT * FROM columnar.options WHERE regclass = 'table_options'::regclass;
+SELECT * FROM columnar.options WHERE relation = 'table_options'::regclass;
 
 -- error: set columnar options on heap tables
 CREATE TABLE heap_options(i int) USING heap;
@@ -204,7 +204,7 @@ DROP TABLE heap_options;
 -- verify options are removed when table is dropped
 DROP TABLE table_options;
 -- we expect no entries in çstore.options for anything not found int pg_class
-SELECT * FROM columnar.options o WHERE o.regclass NOT IN (SELECT oid FROM pg_class);
+SELECT * FROM columnar.options o WHERE o.relation NOT IN (SELECT oid FROM pg_class);
 
 SET client_min_messages TO warning;
 DROP SCHEMA am_tableoptions CASCADE;

src/test/regress/sql/columnar_test_helpers.sql

@@ -1,10 +1,6 @@
 CREATE SCHEMA columnar_test_helpers;
 SET search_path TO columnar_test_helpers;
 
-CREATE FUNCTION columnar_relation_storageid(relid oid) RETURNS bigint
-    LANGUAGE C STABLE STRICT
-    AS 'citus', $$columnar_relation_storageid$$;
-
 CREATE OR REPLACE FUNCTION columnar_storage_info(
     rel regclass,
     version_major OUT int4,
@@ -30,22 +26,22 @@ $$ LANGUAGE plpgsql;
 CREATE view chunk_group_consistency AS
 WITH a as (
    SELECT storage_id, stripe_num, chunk_group_num, min(value_count) as row_count
-   FROM columnar.chunk
+   FROM columnar_internal.chunk
    GROUP BY 1,2,3
 ), b as (
    SELECT storage_id, stripe_num, chunk_group_num, max(value_count) as row_count
-   FROM columnar.chunk
+   FROM columnar_internal.chunk
    GROUP BY 1,2,3
 ), c as (
    (TABLE a EXCEPT TABLE b) UNION (TABLE b EXCEPT TABLE a) UNION
-   (TABLE a EXCEPT TABLE columnar.chunk_group) UNION (TABLE columnar.chunk_group EXCEPT TABLE a)
+   (TABLE a EXCEPT TABLE columnar_internal.chunk_group) UNION (TABLE columnar_internal.chunk_group EXCEPT TABLE a)
 ), d as (
    SELECT storage_id, stripe_num, count(*) as chunk_group_count
-   FROM columnar.chunk_group
+   FROM columnar_internal.chunk_group
    GROUP BY 1,2
 ), e as (
    SELECT storage_id, stripe_num, chunk_group_count
-   FROM columnar.stripe
+   FROM columnar_internal.stripe
 ), f as (
    (TABLE d EXCEPT TABLE e) UNION (TABLE e EXCEPT TABLE d)
 )
@@ -59,9 +55,9 @@ DECLARE
 BEGIN
    SELECT count(*) INTO union_storage_id_count FROM
    (
-   SELECT storage_id FROM columnar.stripe UNION ALL
+   SELECT storage_id FROM columnar_internal.stripe UNION ALL
-   SELECT storage_id FROM columnar.chunk UNION ALL
+   SELECT storage_id FROM columnar_internal.chunk UNION ALL
-   SELECT storage_id FROM columnar.chunk_group
+   SELECT storage_id FROM columnar_internal.chunk_group
    ) AS union_storage_id
    WHERE storage_id=input_storage_id;
 

src/test/regress/sql/columnar_truncate.sql

@@ -90,7 +90,7 @@ INSERT INTO columnar_same_transaction_truncate SELECT * FROM generate_series(20,
 COMMIT;
 
 -- should output "1" for the newly created relation
-SELECT count(distinct storage_id) - :columnar_data_files_before_truncate FROM columnar.stripe;
+SELECT count(distinct storage_id) - :columnar_data_files_before_truncate FROM columnar_internal.stripe;
 SELECT * FROM columnar_same_transaction_truncate;
 
 DROP TABLE columnar_same_transaction_truncate;

src/test/regress/sql/columnar_vacuum.sql

@@ -6,7 +6,7 @@ CREATE TABLE t(a int, b int) USING columnar;
 
 CREATE VIEW t_stripes AS
 SELECT * FROM columnar.stripe a, pg_class b
-WHERE a.storage_id = columnar_test_helpers.columnar_relation_storageid(b.oid) AND b.relname='t';
+WHERE a.storage_id = columnar.get_storage_id(b.oid) AND b.relname='t';
 
 SELECT count(*) FROM t_stripes;
 
@@ -56,13 +56,13 @@ ALTER TABLE t DROP COLUMN a;
 
 SELECT stripe_num, attr_num, chunk_group_num, minimum_value IS NULL, maximum_value IS NULL
 FROM columnar.chunk a, pg_class b
-WHERE a.storage_id = columnar_test_helpers.columnar_relation_storageid(b.oid) AND b.relname='t' ORDER BY 1, 2, 3;
+WHERE a.storage_id = columnar.get_storage_id(b.oid) AND b.relname='t' ORDER BY 1, 2, 3;
 
 VACUUM FULL t;
 
 SELECT stripe_num, attr_num, chunk_group_num, minimum_value IS NULL, maximum_value IS NULL
 FROM columnar.chunk a, pg_class b
-WHERE a.storage_id = columnar_test_helpers.columnar_relation_storageid(b.oid) AND b.relname='t' ORDER BY 1, 2, 3;
+WHERE a.storage_id = columnar.get_storage_id(b.oid) AND b.relname='t' ORDER BY 1, 2, 3;
 
 -- Make sure we cleaned-up the transient table metadata after VACUUM FULL commands
 SELECT count(distinct storage_id) - :columnar_table_count FROM columnar.stripe;

src/test/regress/sql/multi_extension.sql

@@ -92,7 +92,7 @@ FROM pg_depend AS pgd,
 WHERE pgd.refclassid = 'pg_extension'::regclass AND
 	  pgd.refobjid   = pge.oid AND
 	  pge.extname    = 'citus' AND
-	  pgio.schema    NOT IN ('pg_catalog', 'citus', 'citus_internal', 'test', 'columnar')
+	  pgio.schema    NOT IN ('pg_catalog', 'citus', 'citus_internal', 'test', 'columnar', 'columnar_internal')
 ORDER BY 1, 2;
 
 
@@ -490,7 +490,7 @@ FROM pg_depend AS pgd,
 WHERE pgd.refclassid = 'pg_extension'::regclass AND
 	  pgd.refobjid   = pge.oid AND
 	  pge.extname    = 'citus' AND
-	  pgio.schema    NOT IN ('pg_catalog', 'citus', 'citus_internal', 'test', 'columnar')
+	  pgio.schema    NOT IN ('pg_catalog', 'citus', 'citus_internal', 'test', 'columnar', 'columnar_internal')
 ORDER BY 1, 2;
 
 -- see incompatible version errors out

src/test/regress/sql/multi_multiuser.sql

@@ -151,13 +151,12 @@ SET ROLE read_access;
 DROP TABLE columnar_table;
 
 -- cannot modify columnar metadata table as unprivileged user
-INSERT INTO columnar.stripe VALUES(99);
+INSERT INTO columnar_internal.stripe VALUES(99);
 -- Cannot drop columnar metadata table as unprivileged user.
 -- Privileged user also cannot drop but with a different error message.
 -- (since citus extension has a dependency to it)
-DROP TABLE columnar.chunk;
+DROP TABLE columnar_internal.chunk;
 
--- cannot read columnar.chunk since it could expose chunk min/max values
 SELECT * FROM columnar.chunk;
 
 -- test whether a read-only user can read from citus_tables view

src/test/regress/sql/upgrade_columnar_after.sql

@@ -31,11 +31,11 @@ SELECT * FROM test_alter_type ORDER BY a;
 SELECT * FROM matview ORDER BY a;
 
 -- test we retained options
-SELECT * FROM columnar.options WHERE regclass = 'test_options_1'::regclass;
+SELECT * FROM columnar.options WHERE relation = 'test_options_1'::regclass;
 VACUUM VERBOSE test_options_1;
 SELECT count(*), sum(a), sum(b) FROM test_options_1;
 
-SELECT * FROM columnar.options WHERE regclass = 'test_options_2'::regclass;
+SELECT * FROM columnar.options WHERE relation = 'test_options_2'::regclass;
 VACUUM VERBOSE test_options_2;
 SELECT count(*), sum(a), sum(b) FROM test_options_2;
 
@@ -145,7 +145,7 @@ ROLLBACK;
 SELECT pg_class.oid INTO columnar_schema_members
 FROM pg_class, pg_namespace
 WHERE pg_namespace.oid=pg_class.relnamespace AND
-      pg_namespace.nspname='columnar';
+      pg_namespace.nspname='columnar_internal';
 SELECT refobjid INTO columnar_schema_members_pg_depend
 FROM pg_depend
 WHERE classid = 'pg_am'::regclass::oid AND
@@ -173,7 +173,7 @@ $$
 SELECT pg_class.oid INTO columnar_schema_members
 FROM pg_class, pg_namespace
 WHERE pg_namespace.oid=pg_class.relnamespace AND
-	  pg_namespace.nspname='columnar';
+	  pg_namespace.nspname='columnar_internal';
 SELECT refobjid INTO columnar_schema_members_pg_depend
 FROM pg_depend
 WHERE classid = 'pg_am'::regclass::oid AND