external
/
citus
mirror of https://github.com/citusdata/citus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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.
pull/5960/head
jeff-davis 2022-05-20 15:30:31 -07:00 committed by GitHub
parent 52541c5802
commit a2f5b068e6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
40 changed files with 702 additions and 373 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
src/backend/columnar/columnar_metadata.c
View File

@ -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",

69
src/backend/columnar/sql/columnar--11.0-2--11.1-1.sql
View File

@ -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;

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

@ -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;

48
src/backend/columnar/sql/udfs/columnar_ensure_am_depends_catalog/11.1-1.sql Normal file
View File

@ -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';

32
src/backend/columnar/sql/udfs/columnar_ensure_am_depends_catalog/latest.sql
View File

@ -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'),
('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)
FROM columnar_schema_members
-- Avoid inserting duplicate entries into pg_depend.
EXCEPT TABLE pg_depend;
END;

112
src/test/regress/expected/columnar_citus_integration.out
View File

@ -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

12
src/test/regress/expected/columnar_create.out
View File

@ -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

6
src/test/regress/expected/columnar_empty.out
View File

@ -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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
SELECT * FROM columnar.options WHERE relation = 't_compressed'::regclass;
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

6
src/test/regress/expected/columnar_first_row_number.out
View File

@ -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
---------------------------------------------------------------------

33
src/test/regress/expected/columnar_indexes.out
View File

@ -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.chunk SET (autovacuum_enabled = false);
ALTER TABLE columnar.chunk_group SET (autovacuum_enabled = false);
ALTER TABLE columnar_internal.stripe SET (autovacuum_enabled = false);
ALTER TABLE columnar_internal.chunk 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.
-- Here we truncate columnar.chunk and columnar.chunk_group but not
-- columnar.stripe to make sure that we properly handle dead tuples
-- in columnar.stripe, i.e. stripe metadata entries for aborted
-- transactions.
TRUNCATE columnar.chunk, columnar.chunk_group;
-- Already disabled autovacuum for all three metadata tables. Here
-- we truncate columnar_internal.chunk and
-- columnar.chunk_group but not columnar.stripe to
-- make sure that we properly handle dead tuples in
-- columnar.stripe, i.e. stripe metadata entries for
-- 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

6
src/test/regress/expected/columnar_insert.out
View File

@ -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
---------------------------------------------------------------------

20
src/test/regress/expected/columnar_matview.out
View File

@ -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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 't_view'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 't_view'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 't_view'::regclass;
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

118
src/test/regress/expected/columnar_permissions.out
View File

@ -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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
select 1 from columnar.get_storage_id('columnar_permissions'::regclass);
?column?
---------------------------------------------------------------------
columnar_permissions | 10000 | 2222 | 3 | none
1
(1 row)
insert into columnar_permissions values(2,20);
vacuum columnar_permissions;
-- error
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;
-- should error
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);
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;

2
src/test/regress/expected/columnar_recursive.out
View File

@ -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

2
src/test/regress/expected/columnar_rollback.out
View File

@ -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;

136
src/test/regress/expected/columnar_tableoptions.out
View File

@ -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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
SELECT * FROM columnar.options WHERE relation = 'table_options'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
SELECT * FROM columnar.options WHERE relation = 'table_options'::regclass;
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);
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
SELECT * FROM columnar.options o WHERE o.relation NOT IN (SELECT oid FROM pg_class);
relation | chunk_group_row_limit | stripe_row_limit | compression | compression_level
---------------------------------------------------------------------
(0 rows)

19
src/test/regress/expected/columnar_test_helpers.out
View File

@ -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.chunk UNION ALL
SELECT storage_id FROM columnar.chunk_group
SELECT storage_id FROM columnar_internal.stripe UNION ALL
SELECT storage_id FROM columnar_internal.chunk UNION ALL
SELECT storage_id FROM columnar_internal.chunk_group
) AS union_storage_id
WHERE storage_id=input_storage_id;

2
src/test/regress/expected/columnar_truncate.out
View File

@ -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

6
src/test/regress/expected/columnar_vacuum.out
View File

@ -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

27
src/test/regress/expected/multi_extension.out
View File

@ -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
---------------------------------------------------------------------
@ -1051,8 +1051,9 @@ SELECT * FROM multi_extension.print_extension_changes();
-- Snapshot of state at 11.1-1
ALTER EXTENSION citus UPDATE TO '11.1-1';
SELECT * FROM multi_extension.print_extension_changes();
previous_object | current_object
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
---------------------------------------------------------------------

16
src/test/regress/expected/multi_multiuser.out
View File

@ -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);
ERROR: permission denied for table stripe
INSERT INTO columnar_internal.stripe VALUES(99);
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;
ERROR: must be owner of table chunk
-- cannot read columnar.chunk since it could expose chunk min/max values
DROP TABLE columnar_internal.chunk;
ERROR: permission denied for schema columnar_internal
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

16
src/test/regress/expected/upgrade_columnar_after.out
View File

@ -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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
SELECT * FROM columnar.options WHERE relation = 'test_options_1'::regclass;
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;
regclass | chunk_group_row_limit | stripe_row_limit | compression_level | compression
SELECT * FROM columnar.options WHERE relation = 'test_options_2'::regclass;
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

21
src/test/regress/expected/upgrade_list_citus_objects.out
View File

@ -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.chunk_group
table columnar.options
table columnar.stripe
table columnar_internal.chunk
table columnar_internal.chunk_group
table columnar_internal.options
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)

112
src/test/regress/sql/columnar_citus_integration.sql
View File

@ -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);

12
src/test/regress/sql/columnar_create.sql
View File

@ -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;

2
src/test/regress/sql/columnar_empty.sql
View File

@ -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;

6
src/test/regress/sql/columnar_first_row_number.sql
View File

@ -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;

33
src/test/regress/sql/columnar_indexes.sql
View File

@ -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.chunk SET (autovacuum_enabled = false);
ALTER TABLE columnar.chunk_group SET (autovacuum_enabled = false);
ALTER TABLE columnar_internal.stripe SET (autovacuum_enabled = false);
ALTER TABLE columnar_internal.chunk 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.
-- Here we truncate columnar.chunk and columnar.chunk_group but not
-- columnar.stripe to make sure that we properly handle dead tuples
-- in columnar.stripe, i.e. stripe metadata entries for aborted
-- transactions.
TRUNCATE columnar.chunk, columnar.chunk_group;
-- Already disabled autovacuum for all three metadata tables. Here
-- we truncate columnar_internal.chunk and
-- columnar.chunk_group but not columnar.stripe to
-- make sure that we properly handle dead tuples in
-- columnar.stripe, i.e. stripe metadata entries for
-- 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;

6
src/test/regress/sql/columnar_insert.sql
View File

@ -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;

8
src/test/regress/sql/columnar_matview.sql
View File

@ -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;

58
src/test/regress/sql/columnar_permissions.sql
View File

@ -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;

2
src/test/regress/sql/columnar_recursive.sql
View File

@ -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;

2
src/test/regress/sql/columnar_rollback.sql
View File

@ -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;

46
src/test/regress/sql/columnar_tableoptions.sql
View File

@ -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;

20
src/test/regress/sql/columnar_test_helpers.sql
View File

@ -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.chunk UNION ALL
SELECT storage_id FROM columnar.chunk_group
SELECT storage_id FROM columnar_internal.stripe UNION ALL
SELECT storage_id FROM columnar_internal.chunk UNION ALL
SELECT storage_id FROM columnar_internal.chunk_group
) AS union_storage_id
WHERE storage_id=input_storage_id;

2
src/test/regress/sql/columnar_truncate.sql
View File

@ -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;

6
src/test/regress/sql/columnar_vacuum.sql
View File

@ -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;

4
src/test/regress/sql/multi_extension.sql
View File

@ -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

5
src/test/regress/sql/multi_multiuser.sql
View File

@ -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

8
src/test/regress/sql/upgrade_columnar_after.sql
View File

@ -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