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

Mark objects as distributed even when pg_dist_node is empty (#6900) 

We mark objects as distributed objects in Citus metadata only if we need
to propagate given the command that creates it to worker nodes. For this
reason, we were not doing this for the objects that are created while
pg_dist_node is empty.

One implication of doing so is that we defer the schema propagation to
the time when user creates the first distributed table in the schema.
However, this doesn't help for schema-based sharding (#6866) because we
want to sync pg_dist_tenant_schema to the worker nodes even for empty
schemas too.

* Support test dependencies for isolation tests without a schedule

* Comment out a test due to a known issue (#6901)

* Also, reduce the verbosity for some log messages and make some
   tests compatible with run_test.py.
pull/6931/head
Onur Tirtir 2023-05-16 11:45:42 +03:00 committed by GitHub
parent e7abde7e81
commit 56d217b108
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
21 changed files with 284 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
src/backend/distributed/commands/utility_hook.c
View File

@ -1591,37 +1591,37 @@ DDLTaskList(Oid relationId, const char *commandString)
List *
NodeDDLTaskList(TargetWorkerSet targets, List *commands)
{
/* don't allow concurrent node list changes that require an exclusive lock */
List *workerNodes = TargetWorkerSetNodeList(targets, RowShareLock);
if (list_length(workerNodes) <= 0)
{
/*
* if there are no nodes we don't have to plan any ddl tasks. Planning them would
* cause the executor to stop responding.
*/
return NIL;
}
Task *task = CitusMakeNode(Task);
task->taskType = DDL_TASK;
SetTaskQueryStringList(task, commands);
WorkerNode *workerNode = NULL;
foreach_ptr(workerNode, workerNodes)
{
ShardPlacement *targetPlacement = CitusMakeNode(ShardPlacement);
targetPlacement->nodeName = workerNode->workerName;
targetPlacement->nodePort = workerNode->workerPort;
targetPlacement->groupId = workerNode->groupId;
task->taskPlacementList = lappend(task->taskPlacementList, targetPlacement);
}
DDLJob *ddlJob = palloc0(sizeof(DDLJob));
ddlJob->targetObjectAddress = InvalidObjectAddress;
ddlJob->metadataSyncCommand = NULL;
ddlJob->taskList = list_make1(task);
/* don't allow concurrent node list changes that require an exclusive lock */
List *workerNodes = TargetWorkerSetNodeList(targets, RowShareLock);
/*
* if there are no nodes we don't have to plan any ddl tasks. Planning them would
* cause the executor to stop responding.
*/
if (list_length(workerNodes) > 0)
{
Task *task = CitusMakeNode(Task);
task->taskType = DDL_TASK;
SetTaskQueryStringList(task, commands);
WorkerNode *workerNode = NULL;
foreach_ptr(workerNode, workerNodes)
{
ShardPlacement *targetPlacement = CitusMakeNode(ShardPlacement);
targetPlacement->nodeName = workerNode->workerName;
targetPlacement->nodePort = workerNode->workerPort;
targetPlacement->groupId = workerNode->groupId;
task->taskPlacementList = lappend(task->taskPlacementList, targetPlacement);
}
ddlJob->taskList = list_make1(task);
}
return list_make1(ddlJob);
}

6
src/backend/distributed/executor/adaptive_executor.c
View File

@ -1040,6 +1040,12 @@ ExecuteTaskListIntoTupleDest(RowModifyLevel modLevel, List *taskList,
uint64
ExecuteTaskListExtended(ExecutionParams *executionParams)
{
/* if there are no tasks to execute, we can return early */
if (list_length(executionParams->taskList) == 0)
{
return 0;
}
ParamListInfo paramListInfo = NULL;
uint64 locallyProcessedRows = 0;

4
src/backend/distributed/planner/function_call_delegation.c
View File

@ -337,7 +337,7 @@ TryToDelegateFunctionCall(DistributedPlanningContext *planContext)
if (!procedure->forceDelegation)
{
/* cannot delegate function calls in a multi-statement transaction */
ereport(DEBUG1, (errmsg("not pushing down function calls in "
ereport(DEBUG4, (errmsg("not pushing down function calls in "
"a multi-statement transaction")));
return NULL;
}
@ -388,7 +388,7 @@ TryToDelegateFunctionCall(DistributedPlanningContext *planContext)
Oid colocatedRelationId = ColocatedTableId(procedure->colocationId);
if (colocatedRelationId == InvalidOid)
{
ereport(DEBUG1, (errmsg("function does not have co-located tables")));
ereport(DEBUG4, (errmsg("function does not have co-located tables")));
return NULL;
}

7
src/test/regress/citus_tests/run_test.py
View File

@ -129,6 +129,9 @@ DEPS = {
"multi_mx_schema_support": TestDeps(None, ["multi_mx_copy_data"]),
"multi_simple_queries": TestDeps("base_schedule"),
"create_single_shard_table": TestDeps("minimal_schedule"),
"isolation_extension_commands": TestDeps(
None, ["isolation_setup", "isolation_add_remove_node"]
),
}
@ -195,9 +198,9 @@ def run_schedule_with_multiregress(test_name, schedule, dependencies, args):
worker_count = needed_worker_count(test_name, dependencies)
# find suitable make recipe
if dependencies.schedule == "base_isolation_schedule":
if dependencies.schedule == "base_isolation_schedule" or "isolation" in test_name:
make_recipe = "check-isolation-custom-schedule"
elif dependencies.schedule == "failure_base_schedule":
elif dependencies.schedule == "failure_base_schedule" or "failure" in test_name:
make_recipe = "check-failure-custom-schedule"
else:
make_recipe = "check-custom-schedule"

7
src/test/regress/expected/fast_path_router_modify.out
View File

@ -231,7 +231,6 @@ $$ LANGUAGE plpgsql;
DEBUG: switching to sequential query execution mode
DETAIL: A command for a distributed function is run. To make sure subsequent commands see the function correctly we need to make sure to use only one connection for all future commands
SELECT modify_fast_path_plpsql(1,1);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
CONTEXT: SQL statement "DELETE FROM modify_fast_path WHERE key = $1 AND value_1 = $2"
PL/pgSQL function modify_fast_path_plpsql(integer,integer) line XX at SQL statement
@ -244,7 +243,6 @@ PL/pgSQL function modify_fast_path_plpsql(integer,integer) line XX at SQL statem
(1 row)
SELECT modify_fast_path_plpsql(2,2);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
CONTEXT: SQL statement "DELETE FROM modify_fast_path WHERE key = $1 AND value_1 = $2"
PL/pgSQL function modify_fast_path_plpsql(integer,integer) line XX at SQL statement
@ -257,7 +255,6 @@ PL/pgSQL function modify_fast_path_plpsql(integer,integer) line XX at SQL statem
(1 row)
SELECT modify_fast_path_plpsql(3,3);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
CONTEXT: SQL statement "DELETE FROM modify_fast_path WHERE key = $1 AND value_1 = $2"
PL/pgSQL function modify_fast_path_plpsql(integer,integer) line XX at SQL statement
@ -270,7 +267,6 @@ PL/pgSQL function modify_fast_path_plpsql(integer,integer) line XX at SQL statem
(1 row)
SELECT modify_fast_path_plpsql(4,4);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
CONTEXT: SQL statement "DELETE FROM modify_fast_path WHERE key = $1 AND value_1 = $2"
PL/pgSQL function modify_fast_path_plpsql(integer,integer) line XX at SQL statement
@ -283,7 +279,6 @@ PL/pgSQL function modify_fast_path_plpsql(integer,integer) line XX at SQL statem
(1 row)
SELECT modify_fast_path_plpsql(5,5);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
CONTEXT: SQL statement "DELETE FROM modify_fast_path WHERE key = $1 AND value_1 = $2"
PL/pgSQL function modify_fast_path_plpsql(integer,integer) line XX at SQL statement
@ -296,7 +291,6 @@ PL/pgSQL function modify_fast_path_plpsql(integer,integer) line XX at SQL statem
(1 row)
SELECT modify_fast_path_plpsql(6,6);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
CONTEXT: SQL statement "DELETE FROM modify_fast_path WHERE key = $1 AND value_1 = $2"
PL/pgSQL function modify_fast_path_plpsql(integer,integer) line XX at SQL statement
@ -309,7 +303,6 @@ PL/pgSQL function modify_fast_path_plpsql(integer,integer) line XX at SQL statem
(1 row)
SELECT modify_fast_path_plpsql(6,6);
DEBUG: function does not have co-located tables
modify_fast_path_plpsql
---------------------------------------------------------------------

17
src/test/regress/expected/forcedelegation_functions.out
View File

@ -322,7 +322,6 @@ SELECT public.wait_until_metadata_sync(30000);
BEGIN;
SELECT func_calls_forcepush_func();
DEBUG: not pushing down function calls in a multi-statement transaction
DEBUG: pushing down function call in a multi-statement transaction
CONTEXT: SQL statement "SELECT inner_force_delegation_function FROM inner_force_delegation_function(100)"
PL/pgSQL function func_calls_forcepush_func() line XX at SQL statement
@ -340,7 +339,6 @@ PL/pgSQL function func_calls_forcepush_func() line XX at SQL statement
COMMIT;
SELECT func_calls_forcepush_func();
DEBUG: function does not have co-located tables
NOTICE: inner_force_delegation_function():101
DETAIL: from localhost:xxxxx
CONTEXT: SQL statement "SELECT inner_force_delegation_function FROM inner_force_delegation_function(100)"
@ -380,7 +378,6 @@ $$ LANGUAGE plpgsql;
DEBUG: switching to sequential query execution mode
DETAIL: A command for a distributed function is run. To make sure subsequent commands see the function correctly we need to make sure to use only one connection for all future commands
SELECT func_calls_forcepush_func_infrom();
DEBUG: function does not have co-located tables
DEBUG: pushing down function call in a multi-statement transaction
CONTEXT: SQL statement "SELECT inner_force_delegation_function FROM inner_force_delegation_function(add_val + 100)"
PL/pgSQL function func_calls_forcepush_func_infrom() line XX at SQL statement
@ -398,7 +395,6 @@ PL/pgSQL function func_calls_forcepush_func_infrom() line XX at SQL statement
BEGIN;
SELECT func_calls_forcepush_func_infrom();
DEBUG: not pushing down function calls in a multi-statement transaction
DEBUG: pushing down function call in a multi-statement transaction
CONTEXT: SQL statement "SELECT inner_force_delegation_function FROM inner_force_delegation_function(add_val + 100)"
PL/pgSQL function func_calls_forcepush_func_infrom() line XX at SQL statement
@ -435,7 +431,6 @@ $$ LANGUAGE plpgsql;
DEBUG: switching to sequential query execution mode
DETAIL: A command for a distributed function is run. To make sure subsequent commands see the function correctly we need to make sure to use only one connection for all future commands
SELECT func_calls_forcepush_func_intarget();
DEBUG: function does not have co-located tables
DEBUG: pushing down function call in a multi-statement transaction
CONTEXT: SQL statement "SELECT inner_force_delegation_function(100 + 100) OFFSET 0"
PL/pgSQL function func_calls_forcepush_func_intarget() line XX at SQL statement
@ -453,7 +448,6 @@ PL/pgSQL function func_calls_forcepush_func_intarget() line XX at SQL statement
BEGIN;
SELECT func_calls_forcepush_func_intarget();
DEBUG: not pushing down function calls in a multi-statement transaction
NOTICE: inner_force_delegation_function():201
DETAIL: from localhost:xxxxx
CONTEXT: SQL statement "SELECT inner_force_delegation_function(100 + 100) OFFSET 0"
@ -648,7 +642,6 @@ DETAIL: A command for a distributed function is run. To make sure subsequent co
(1 row)
SELECT outer_emp();
DEBUG: function does not have co-located tables
DEBUG: Skipping pushdown of function from a PL/PgSQL simple expression
CONTEXT: SQL statement "SELECT inner_emp('hello')"
PL/pgSQL function outer_emp() line XX at PERFORM
@ -1282,7 +1275,6 @@ DETAIL: A command for a distributed function is run. To make sure subsequent co
-- First 5 get delegated and succeeds
BEGIN;
SELECT outer_test_prepare(1,1);
DEBUG: not pushing down function calls in a multi-statement transaction
DEBUG: pushing down function call in a multi-statement transaction
CONTEXT: SQL statement "SELECT FROM test_prepare(x, y)"
PL/pgSQL function outer_test_prepare(integer,integer) line XX at PERFORM
@ -1301,7 +1293,6 @@ PL/pgSQL function outer_test_prepare(integer,integer) line XX at PERFORM
(1 row)
SELECT outer_test_prepare(1,1);
DEBUG: not pushing down function calls in a multi-statement transaction
DEBUG: pushing down function call in a multi-statement transaction
CONTEXT: SQL statement "SELECT FROM test_prepare(x, y)"
PL/pgSQL function outer_test_prepare(integer,integer) line XX at PERFORM
@ -1320,7 +1311,6 @@ PL/pgSQL function outer_test_prepare(integer,integer) line XX at PERFORM
(1 row)
SELECT outer_test_prepare(1,1);
DEBUG: not pushing down function calls in a multi-statement transaction
DEBUG: pushing down function call in a multi-statement transaction
CONTEXT: SQL statement "SELECT FROM test_prepare(x, y)"
PL/pgSQL function outer_test_prepare(integer,integer) line XX at PERFORM
@ -1339,7 +1329,6 @@ PL/pgSQL function outer_test_prepare(integer,integer) line XX at PERFORM
(1 row)
SELECT outer_test_prepare(1,1);
DEBUG: not pushing down function calls in a multi-statement transaction
DEBUG: pushing down function call in a multi-statement transaction
CONTEXT: SQL statement "SELECT FROM test_prepare(x, y)"
PL/pgSQL function outer_test_prepare(integer,integer) line XX at PERFORM
@ -1358,7 +1347,6 @@ PL/pgSQL function outer_test_prepare(integer,integer) line XX at PERFORM
(1 row)
SELECT outer_test_prepare(1,1);
DEBUG: not pushing down function calls in a multi-statement transaction
DEBUG: pushing down function call in a multi-statement transaction
CONTEXT: SQL statement "SELECT FROM test_prepare(x, y)"
PL/pgSQL function outer_test_prepare(integer,integer) line XX at PERFORM
@ -1385,7 +1373,6 @@ SELECT COUNT(*) FROM table_test_prepare;
-- 6th execution will be generic plan and should get delegated
SELECT outer_test_prepare(1,1);
DEBUG: not pushing down function calls in a multi-statement transaction
DEBUG: pushing down function call in a multi-statement transaction
CONTEXT: SQL statement "SELECT FROM test_prepare(x, y)"
PL/pgSQL function outer_test_prepare(integer,integer) line XX at PERFORM
@ -1404,7 +1391,6 @@ PL/pgSQL function outer_test_prepare(integer,integer) line XX at PERFORM
(1 row)
SELECT outer_test_prepare(1,1);
DEBUG: not pushing down function calls in a multi-statement transaction
DEBUG: pushing down function call in a multi-statement transaction
CONTEXT: SQL statement "SELECT FROM test_prepare(x, y)"
PL/pgSQL function outer_test_prepare(integer,integer) line XX at PERFORM
@ -1425,7 +1411,6 @@ PL/pgSQL function outer_test_prepare(integer,integer) line XX at PERFORM
END;
-- Fails as expected
SELECT outer_test_prepare(1,2);
DEBUG: function does not have co-located tables
DEBUG: pushing down function call in a multi-statement transaction
CONTEXT: SQL statement "SELECT FROM test_prepare(x, y)"
PL/pgSQL function outer_test_prepare(integer,integer) line XX at PERFORM
@ -1525,7 +1510,6 @@ DETAIL: A command for a distributed function is run. To make sure subsequent co
(1 row)
SELECT outer_local_fn();
DEBUG: function does not have co-located tables
DEBUG: pushing down function call in a multi-statement transaction
CONTEXT: SQL statement "SELECT 1 FROM inner_fn(1)"
PL/pgSQL function outer_local_fn() line XX at PERFORM
@ -1555,7 +1539,6 @@ SELECT * FROM testnested_table ORDER BY 1;
BEGIN;
SELECT outer_local_fn();
DEBUG: not pushing down function calls in a multi-statement transaction
outer_local_fn
---------------------------------------------------------------------

1
src/test/regress/expected/insert_select_single_shard_table.out
View File

@ -719,7 +719,6 @@ INSERT INTO upsert_test_1 (unique_col, other_col) SELECT unique_col, other_col F
DO UPDATE SET other_col = 5 WHERE upsert_test_1.other_col = random()::int;
ERROR: functions used in the WHERE clause of the ON CONFLICT clause of INSERTs on distributed tables must be marked IMMUTABLE
SELECT reload_tables();
DEBUG: function does not have co-located tables
reload_tables
---------------------------------------------------------------------

90
src/test/regress/expected/isolation_ensure_dependency_activate_node.out
View File

@ -29,9 +29,10 @@ step s1-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(3 rows)
(4 rows)
count
---------------------------------------------------------------------
@ -116,10 +117,11 @@ step s2-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(table,"{public,t1}",{})
(4 rows)
(5 rows)
count
---------------------------------------------------------------------
@ -200,9 +202,10 @@ step s1-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(3 rows)
(4 rows)
count
---------------------------------------------------------------------
@ -293,10 +296,11 @@ step s2-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(table,"{public,t1}",{})
(4 rows)
(5 rows)
count
---------------------------------------------------------------------
@ -377,9 +381,10 @@ step s1-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(3 rows)
(4 rows)
count
---------------------------------------------------------------------
@ -470,10 +475,11 @@ step s2-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(table,"{public,t1}",{})
(4 rows)
(5 rows)
count
---------------------------------------------------------------------
@ -554,9 +560,10 @@ step s1-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(3 rows)
(4 rows)
count
---------------------------------------------------------------------
@ -642,11 +649,12 @@ step s2-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{myschema},{})
(schema,{public},{})
(table,"{myschema,t1}",{})
(5 rows)
(6 rows)
count
---------------------------------------------------------------------
@ -727,9 +735,10 @@ step s1-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(3 rows)
(4 rows)
count
---------------------------------------------------------------------
@ -821,11 +830,12 @@ step s2-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{myschema},{})
(schema,{public},{})
(table,"{myschema,t1}",{})
(5 rows)
(6 rows)
count
---------------------------------------------------------------------
@ -906,9 +916,10 @@ step s1-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(3 rows)
(4 rows)
count
---------------------------------------------------------------------
@ -1000,11 +1011,12 @@ step s2-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{myschema},{})
(schema,{public},{})
(table,"{myschema,t1}",{})
(5 rows)
(6 rows)
count
---------------------------------------------------------------------
@ -1085,9 +1097,10 @@ step s1-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(3 rows)
(4 rows)
count
---------------------------------------------------------------------
@ -1179,11 +1192,12 @@ step s2-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{myschema},{})
(schema,{public},{})
(table,"{myschema,t1}",{})
(5 rows)
(6 rows)
count
---------------------------------------------------------------------
@ -1264,9 +1278,10 @@ step s1-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(3 rows)
(4 rows)
count
---------------------------------------------------------------------
@ -1381,6 +1396,7 @@ step s2-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{col_schema},{})
(schema,{myschema},{})
@ -1388,7 +1404,7 @@ pg_identify_object_as_address
(table,"{col_schema,col_tbl}",{})
(table,"{myschema,t1}",{})
(table,"{myschema,t2}",{})
(8 rows)
(9 rows)
count
---------------------------------------------------------------------
@ -1469,9 +1485,10 @@ step s1-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(3 rows)
(4 rows)
count
---------------------------------------------------------------------
@ -1585,13 +1602,14 @@ step s2-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{myschema},{})
(schema,{myschema2},{})
(schema,{public},{})
(table,"{myschema,t1}",{})
(table,"{myschema2,t2}",{})
(7 rows)
(8 rows)
count
---------------------------------------------------------------------
@ -1672,9 +1690,10 @@ step s1-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(3 rows)
(4 rows)
count
---------------------------------------------------------------------
@ -1751,10 +1770,11 @@ step s2-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(type,{public.tt1},{})
(4 rows)
(5 rows)
count
---------------------------------------------------------------------
@ -1835,9 +1855,10 @@ step s1-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(3 rows)
(4 rows)
count
---------------------------------------------------------------------
@ -1913,10 +1934,11 @@ step s2-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(type,{public.tt1},{})
(4 rows)
(5 rows)
count
---------------------------------------------------------------------
@ -1997,9 +2019,10 @@ step s1-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(3 rows)
(4 rows)
count
---------------------------------------------------------------------
@ -2094,12 +2117,13 @@ step s2-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{myschema},{})
(schema,{public},{})
(table,"{myschema,t1}",{})
(type,{myschema.tt1},{})
(6 rows)
(7 rows)
count
---------------------------------------------------------------------
@ -2180,9 +2204,10 @@ step s1-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(3 rows)
(4 rows)
count
---------------------------------------------------------------------
@ -2290,11 +2315,12 @@ pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,add}","{integer,integer}")
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{col_schema},{})
(schema,{public},{})
(table,"{col_schema,col_tbl}",{})
(6 rows)
(7 rows)
count
---------------------------------------------------------------------
@ -2375,9 +2401,10 @@ step s1-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(3 rows)
(4 rows)
count
---------------------------------------------------------------------
@ -2492,11 +2519,12 @@ pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,add}","{integer,integer}")
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{col_schema},{})
(schema,{public},{})
(table,"{col_schema,col_tbl}",{})
(6 rows)
(7 rows)
count
---------------------------------------------------------------------
@ -2577,9 +2605,10 @@ step s1-print-distributed-objects:
pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(3 rows)
(4 rows)
count
---------------------------------------------------------------------
@ -2695,12 +2724,13 @@ pg_identify_object_as_address
---------------------------------------------------------------------
(database,{regression},{})
(function,"{myschema,add}","{integer,integer}")
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{col_schema},{})
(schema,{myschema},{})
(schema,{public},{})
(table,"{col_schema,col_tbl}",{})
(7 rows)
(8 rows)
count
---------------------------------------------------------------------

217
src/test/regress/expected/isolation_extension_commands.out
View File

@ -20,16 +20,23 @@ step s1-commit:
step s2-create-extension-version-11: <... completed>
step s1-print:
select count(*) from pg_catalog.pg_dist_object ;
select pg_identify_object_as_address(classid, objid, objsubid)::text as obj_repr from pg_dist_object order by obj_repr;
select extname, extversion, nspname from pg_extension, pg_namespace where pg_namespace.oid=pg_extension.extnamespace and extname='seg';
SELECT run_command_on_workers($$select extname from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select extversion from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select nspname from pg_extension, pg_namespace where extname='seg' and pg_extension.extnamespace=pg_namespace.oid$$);
count
obj_repr
---------------------------------------------------------------------
7
(1 row)
(database,{regression},{})
(extension,{seg},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(schema,{schema1},{})
(schema,{schema2},{})
(schema,{schema3},{})
(8 rows)
extname|extversion|nspname
---------------------------------------------------------------------
@ -81,16 +88,23 @@ step s1-commit:
step s2-alter-extension-update-to-version-12: <... completed>
step s1-print:
select count(*) from pg_catalog.pg_dist_object ;
select pg_identify_object_as_address(classid, objid, objsubid)::text as obj_repr from pg_dist_object order by obj_repr;
select extname, extversion, nspname from pg_extension, pg_namespace where pg_namespace.oid=pg_extension.extnamespace and extname='seg';
SELECT run_command_on_workers($$select extname from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select extversion from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select nspname from pg_extension, pg_namespace where extname='seg' and pg_extension.extnamespace=pg_namespace.oid$$);
count
obj_repr
---------------------------------------------------------------------
7
(1 row)
(database,{regression},{})
(extension,{seg},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(schema,{schema1},{})
(schema,{schema2},{})
(schema,{schema3},{})
(8 rows)
extname|extversion|nspname
---------------------------------------------------------------------
@ -150,16 +164,22 @@ step s1-commit:
step s2-drop-extension: <... completed>
step s1-print:
select count(*) from pg_catalog.pg_dist_object ;
select pg_identify_object_as_address(classid, objid, objsubid)::text as obj_repr from pg_dist_object order by obj_repr;
select extname, extversion, nspname from pg_extension, pg_namespace where pg_namespace.oid=pg_extension.extnamespace and extname='seg';
SELECT run_command_on_workers($$select extname from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select extversion from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select nspname from pg_extension, pg_namespace where extname='seg' and pg_extension.extnamespace=pg_namespace.oid$$);
count
obj_repr
---------------------------------------------------------------------
6
(1 row)
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(schema,{schema1},{})
(schema,{schema2},{})
(schema,{schema3},{})
(7 rows)
extname|extversion|nspname
---------------------------------------------------------------------
@ -206,16 +226,23 @@ step s1-commit:
step s2-create-extension-with-schema1: <... completed>
step s1-print:
select count(*) from pg_catalog.pg_dist_object ;
select pg_identify_object_as_address(classid, objid, objsubid)::text as obj_repr from pg_dist_object order by obj_repr;
select extname, extversion, nspname from pg_extension, pg_namespace where pg_namespace.oid=pg_extension.extnamespace and extname='seg';
SELECT run_command_on_workers($$select extname from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select extversion from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select nspname from pg_extension, pg_namespace where extname='seg' and pg_extension.extnamespace=pg_namespace.oid$$);
count
obj_repr
---------------------------------------------------------------------
7
(1 row)
(database,{regression},{})
(extension,{seg},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(schema,{schema1},{})
(schema,{schema2},{})
(schema,{schema3},{})
(8 rows)
extname|extversion|nspname
---------------------------------------------------------------------
@ -267,16 +294,22 @@ step s1-commit:
step s2-drop-extension: <... completed>
step s1-print:
select count(*) from pg_catalog.pg_dist_object ;
select pg_identify_object_as_address(classid, objid, objsubid)::text as obj_repr from pg_dist_object order by obj_repr;
select extname, extversion, nspname from pg_extension, pg_namespace where pg_namespace.oid=pg_extension.extnamespace and extname='seg';
SELECT run_command_on_workers($$select extname from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select extversion from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select nspname from pg_extension, pg_namespace where extname='seg' and pg_extension.extnamespace=pg_namespace.oid$$);
count
obj_repr
---------------------------------------------------------------------
6
(1 row)
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(schema,{schema1},{})
(schema,{schema2},{})
(schema,{schema3},{})
(7 rows)
extname|extversion|nspname
---------------------------------------------------------------------
@ -338,16 +371,23 @@ step s1-commit:
step s2-alter-extension-set-schema3: <... completed>
step s1-print:
select count(*) from pg_catalog.pg_dist_object ;
select pg_identify_object_as_address(classid, objid, objsubid)::text as obj_repr from pg_dist_object order by obj_repr;
select extname, extversion, nspname from pg_extension, pg_namespace where pg_namespace.oid=pg_extension.extnamespace and extname='seg';
SELECT run_command_on_workers($$select extname from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select extversion from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select nspname from pg_extension, pg_namespace where extname='seg' and pg_extension.extnamespace=pg_namespace.oid$$);
count
obj_repr
---------------------------------------------------------------------
7
(1 row)
(database,{regression},{})
(extension,{seg},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(schema,{schema1},{})
(schema,{schema2},{})
(schema,{schema3},{})
(8 rows)
extname|extversion|nspname
---------------------------------------------------------------------
@ -406,16 +446,23 @@ step s1-commit:
step s2-create-extension-with-schema1: <... completed>
step s1-print:
select count(*) from pg_catalog.pg_dist_object ;
select pg_identify_object_as_address(classid, objid, objsubid)::text as obj_repr from pg_dist_object order by obj_repr;
select extname, extversion, nspname from pg_extension, pg_namespace where pg_namespace.oid=pg_extension.extnamespace and extname='seg';
SELECT run_command_on_workers($$select extname from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select extversion from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select nspname from pg_extension, pg_namespace where extname='seg' and pg_extension.extnamespace=pg_namespace.oid$$);
count
obj_repr
---------------------------------------------------------------------
7
(1 row)
(database,{regression},{})
(extension,{seg},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(schema,{schema1},{})
(schema,{schema2},{})
(schema,{schema3},{})
(8 rows)
extname|extversion|nspname
---------------------------------------------------------------------
@ -482,16 +529,23 @@ step s1-add-node-1: <... completed>
(1 row)
step s1-print:
select count(*) from pg_catalog.pg_dist_object ;
select pg_identify_object_as_address(classid, objid, objsubid)::text as obj_repr from pg_dist_object order by obj_repr;
select extname, extversion, nspname from pg_extension, pg_namespace where pg_namespace.oid=pg_extension.extnamespace and extname='seg';
SELECT run_command_on_workers($$select extname from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select extversion from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select nspname from pg_extension, pg_namespace where extname='seg' and pg_extension.extnamespace=pg_namespace.oid$$);
count
obj_repr
---------------------------------------------------------------------
7
(1 row)
(database,{regression},{})
(extension,{seg},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(schema,{schema1},{})
(schema,{schema2},{})
(schema,{schema3},{})
(8 rows)
extname|extversion|nspname
---------------------------------------------------------------------
@ -565,16 +619,23 @@ step s1-add-node-1: <... completed>
(1 row)
step s1-print:
select count(*) from pg_catalog.pg_dist_object ;
select pg_identify_object_as_address(classid, objid, objsubid)::text as obj_repr from pg_dist_object order by obj_repr;
select extname, extversion, nspname from pg_extension, pg_namespace where pg_namespace.oid=pg_extension.extnamespace and extname='seg';
SELECT run_command_on_workers($$select extname from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select extversion from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select nspname from pg_extension, pg_namespace where extname='seg' and pg_extension.extnamespace=pg_namespace.oid$$);
count
obj_repr
---------------------------------------------------------------------
7
(1 row)
(database,{regression},{})
(extension,{seg},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(schema,{schema1},{})
(schema,{schema2},{})
(schema,{schema3},{})
(8 rows)
extname|extversion|nspname
---------------------------------------------------------------------
@ -634,16 +695,22 @@ step s1-remove-node-1: <... completed>
(1 row)
step s1-print:
select count(*) from pg_catalog.pg_dist_object ;
select pg_identify_object_as_address(classid, objid, objsubid)::text as obj_repr from pg_dist_object order by obj_repr;
select extname, extversion, nspname from pg_extension, pg_namespace where pg_namespace.oid=pg_extension.extnamespace and extname='seg';
SELECT run_command_on_workers($$select extname from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select extversion from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select nspname from pg_extension, pg_namespace where extname='seg' and pg_extension.extnamespace=pg_namespace.oid$$);
count
obj_repr
---------------------------------------------------------------------
6
(1 row)
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(schema,{schema1},{})
(schema,{schema2},{})
(schema,{schema3},{})
(7 rows)
extname|extversion|nspname
---------------------------------------------------------------------
@ -690,16 +757,23 @@ step s1-add-node-1: <... completed>
(1 row)
step s1-print:
select count(*) from pg_catalog.pg_dist_object ;
select pg_identify_object_as_address(classid, objid, objsubid)::text as obj_repr from pg_dist_object order by obj_repr;
select extname, extversion, nspname from pg_extension, pg_namespace where pg_namespace.oid=pg_extension.extnamespace and extname='seg';
SELECT run_command_on_workers($$select extname from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select extversion from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select nspname from pg_extension, pg_namespace where extname='seg' and pg_extension.extnamespace=pg_namespace.oid$$);
count
obj_repr
---------------------------------------------------------------------
7
(1 row)
(database,{regression},{})
(extension,{seg},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(schema,{schema1},{})
(schema,{schema2},{})
(schema,{schema3},{})
(8 rows)
extname|extversion|nspname
---------------------------------------------------------------------
@ -765,16 +839,23 @@ step s1-remove-node-1: <... completed>
(1 row)
step s1-print:
select count(*) from pg_catalog.pg_dist_object ;
select pg_identify_object_as_address(classid, objid, objsubid)::text as obj_repr from pg_dist_object order by obj_repr;
select extname, extversion, nspname from pg_extension, pg_namespace where pg_namespace.oid=pg_extension.extnamespace and extname='seg';
SELECT run_command_on_workers($$select extname from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select extversion from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select nspname from pg_extension, pg_namespace where extname='seg' and pg_extension.extnamespace=pg_namespace.oid$$);
count
obj_repr
---------------------------------------------------------------------
7
(1 row)
(database,{regression},{})
(extension,{seg},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(schema,{schema1},{})
(schema,{schema2},{})
(schema,{schema3},{})
(8 rows)
extname|extversion|nspname
---------------------------------------------------------------------
@ -833,16 +914,23 @@ step s1-remove-node-1: <... completed>
(1 row)
step s1-print:
select count(*) from pg_catalog.pg_dist_object ;
select pg_identify_object_as_address(classid, objid, objsubid)::text as obj_repr from pg_dist_object order by obj_repr;
select extname, extversion, nspname from pg_extension, pg_namespace where pg_namespace.oid=pg_extension.extnamespace and extname='seg';
SELECT run_command_on_workers($$select extname from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select extversion from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select nspname from pg_extension, pg_namespace where extname='seg' and pg_extension.extnamespace=pg_namespace.oid$$);
count
obj_repr
---------------------------------------------------------------------
7
(1 row)
(database,{regression},{})
(extension,{seg},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(schema,{schema1},{})
(schema,{schema2},{})
(schema,{schema3},{})
(8 rows)
extname|extversion|nspname
---------------------------------------------------------------------
@ -870,7 +958,7 @@ master_remove_node
(1 row)
starting permutation: s2-drop-extension s2-add-node-1 s2-create-extension-version-11 s2-remove-node-1 s2-begin s2-drop-extension s1-add-node-1 s2-commit s1-print
starting permutation: s2-drop-extension s2-add-node-1 s2-create-extension-version-11 s2-remove-node-1 s2-begin s2-drop-extension s1-add-node-1 s2-commit s1-print s1-cleanup-node-1
step s2-drop-extension:
drop extension seg;
@ -912,16 +1000,22 @@ step s1-add-node-1: <... completed>
(1 row)
step s1-print:
select count(*) from pg_catalog.pg_dist_object ;
select pg_identify_object_as_address(classid, objid, objsubid)::text as obj_repr from pg_dist_object order by obj_repr;
select extname, extversion, nspname from pg_extension, pg_namespace where pg_namespace.oid=pg_extension.extnamespace and extname='seg';
SELECT run_command_on_workers($$select extname from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select extversion from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select nspname from pg_extension, pg_namespace where extname='seg' and pg_extension.extnamespace=pg_namespace.oid$$);
count
obj_repr
---------------------------------------------------------------------
6
(1 row)
(database,{regression},{})
(function,"{public,wait_until_metadata_sync}",{integer})
(role,{postgres},{})
(schema,{public},{})
(schema,{schema1},{})
(schema,{schema2},{})
(schema,{schema3},{})
(7 rows)
extname|extversion|nspname
---------------------------------------------------------------------
@ -945,6 +1039,15 @@ run_command_on_workers
(localhost,57638,t,"")
(2 rows)
step s1-cleanup-node-1:
SELECT run_command_on_workers($$drop extension if exists seg$$);
run_command_on_workers
---------------------------------------------------------------------
(localhost,57637,t,"DROP EXTENSION")
(localhost,57638,t,"DROP EXTENSION")
(2 rows)
master_remove_node
---------------------------------------------------------------------

9
src/test/regress/expected/multi_drop_extension.out
View File

@ -43,8 +43,13 @@ BEGIN;
(1 row)
alter table other_schema.l3 add constraint fkey foreign key (a) references l1(a);
-- show that works fine
drop schema public cascade;
-- Commented out because it fails due to the issue documented in
-- https://github.com/citusdata/citus/issues/6901.
--
-- This wasn't the case before https://github.com/citusdata/citus/pull/6900.
-- This is because, we were not marking the schemas as distributed when there
-- are no worker nodes in the cluster before that PR.
-- drop schema public cascade;
ROLLBACK;
CREATE EXTENSION citus;
CREATE SCHEMA test_schema;

5
src/test/regress/expected/multi_function_in_join.out
View File

@ -57,7 +57,6 @@ $$ LANGUAGE plpgsql;
DEBUG: switching to sequential query execution mode
DETAIL: A command for a distributed function is run. To make sure subsequent commands see the function correctly we need to make sure to use only one connection for all future commands
SELECT * FROM table1 JOIN increment(2) val ON (id = val) ORDER BY id ASC;
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT val FROM functions_in_joins.increment(2) val(val)
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT table1.id, table1.data, val.val FROM (functions_in_joins.table1 JOIN (SELECT intermediate_result.val FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(val integer)) val ON ((table1.id OPERATOR(pg_catalog.=) val.val))) ORDER BY table1.id
id | data | val
@ -96,7 +95,6 @@ LANGUAGE SQL;
DEBUG: switching to sequential query execution mode
DETAIL: A command for a distributed function is run. To make sure subsequent commands see the function correctly we need to make sure to use only one connection for all future commands
SELECT * FROM table1 JOIN get_set_of_records() AS t2(x int, y int) ON (id = x) ORDER BY id ASC;
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT x, y FROM functions_in_joins.get_set_of_records() t2(x integer, y integer)
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT table1.id, table1.data, t2.x, t2.y FROM (functions_in_joins.table1 JOIN (SELECT intermediate_result.x, intermediate_result.y FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(x integer, y integer)) t2 ON ((table1.id OPERATOR(pg_catalog.=) t2.x))) ORDER BY table1.id
id | data | x | y
@ -114,7 +112,6 @@ LANGUAGE SQL;
DEBUG: switching to sequential query execution mode
DETAIL: A command for a distributed function is run. To make sure subsequent commands see the function correctly we need to make sure to use only one connection for all future commands
SELECT f.* FROM table1 t JOIN dup(32) f ON (f1 = id);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT f1, f2 FROM functions_in_joins.dup(32) f(f1, f2)
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT f.f1, f.f2 FROM (functions_in_joins.table1 t JOIN (SELECT intermediate_result.f1, intermediate_result.f2 FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(f1 integer, f2 text)) f ON ((f.f1 OPERATOR(pg_catalog.=) t.id)))
f1 | f2
@ -128,7 +125,6 @@ CREATE OR REPLACE FUNCTION the_minimum_id()
DEBUG: switching to sequential query execution mode
DETAIL: A command for a distributed function is run. To make sure subsequent commands see the function correctly we need to make sure to use only one connection for all future commands
SELECT * FROM table1 JOIN the_minimum_id() min_id ON (id = min_id);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT min_id FROM functions_in_joins.the_minimum_id() min_id(min_id)
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT table1.id, table1.data, min_id.min_id FROM (functions_in_joins.table1 JOIN (SELECT intermediate_result.min_id FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(min_id integer)) min_id ON ((table1.id OPERATOR(pg_catalog.=) min_id.min_id)))
id | data | min_id
@ -192,7 +188,6 @@ $$ language plpgsql;
DEBUG: switching to sequential query execution mode
DETAIL: A command for a distributed function is run. To make sure subsequent commands see the function correctly we need to make sure to use only one connection for all future commands
SELECT * FROM table1 JOIN max_and_min() m ON (m.maximum = data OR m.minimum = data) ORDER BY 1,2,3,4;
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT minimum, maximum FROM functions_in_joins.max_and_min() m(minimum, maximum)
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT table1.id, table1.data, m.minimum, m.maximum FROM (functions_in_joins.table1 JOIN (SELECT intermediate_result.minimum, intermediate_result.maximum FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(minimum integer, maximum integer)) m ON (((m.maximum OPERATOR(pg_catalog.=) table1.data) OR (m.minimum OPERATOR(pg_catalog.=) table1.data)))) ORDER BY table1.id, table1.data, m.minimum, m.maximum
id | data | minimum | maximum

9
src/test/regress/expected/multi_mx_function_call_delegation.out
View File

@ -170,7 +170,6 @@ NOTICE: procedure multi_mx_function_call_delegation.squares is already distribu
-- colocated with any distributed tables.
SET client_min_messages TO DEBUG1;
select mx_call_func(2, 0);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT sum((t1.val OPERATOR(pg_catalog.+) t2.val)) AS sum FROM (multi_mx_function_call_delegation.mx_call_dist_table_1 t1 JOIN multi_mx_function_call_delegation.mx_call_dist_table_2 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.id)))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT ((3 OPERATOR(pg_catalog.+) (SELECT intermediate_result.sum FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(sum bigint))))::integer
mx_call_func
@ -179,14 +178,12 @@ DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT ((3 OPERATOR(
(1 row)
select multi_mx_function_call_delegation.mx_call_func_bigint(4, 2);
DEBUG: function does not have co-located tables
mx_call_func_bigint
---------------------------------------------------------------------
8
(1 row)
select mx_call_func_custom_types('S', 'A');
DEBUG: function does not have co-located tables
mx_call_func_custom_types
---------------------------------------------------------------------
(F,S)
@ -286,7 +283,6 @@ RESET citus.enable_binary_protocol;
-- We don't allow distributing calls inside transactions
begin;
select mx_call_func(2, 0);
DEBUG: not pushing down function calls in a multi-statement transaction
DEBUG: generating subplan XXX_1 for subquery SELECT sum((t1.val OPERATOR(pg_catalog.+) t2.val)) AS sum FROM (multi_mx_function_call_delegation.mx_call_dist_table_1 t1 JOIN multi_mx_function_call_delegation.mx_call_dist_table_2 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.id)))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT ((3 OPERATOR(pg_catalog.+) (SELECT intermediate_result.sum FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(sum bigint))))::integer
mx_call_func
@ -301,7 +297,6 @@ SET client_min_messages TO NOTICE;
drop table mx_call_dist_table_enum;
SET client_min_messages TO DEBUG1;
select mx_call_func_custom_types('S', 'A');
DEBUG: function does not have co-located tables
mx_call_func_custom_types
---------------------------------------------------------------------
(F,S)
@ -395,7 +390,6 @@ END;$$;
DEBUG: switching to sequential query execution mode
-- before distribution ...
select mx_call_func_tbl(10);
DEBUG: function does not have co-located tables
mx_call_func_tbl
---------------------------------------------------------------------
(10,-1)
@ -685,7 +679,6 @@ ERROR: cannot execute a distributed query from a query on a shard
select mx_call_func_copy(2) from mx_call_dist_table_1 where id = 3;
ERROR: cannot execute a distributed query from a query on a shard
DO $$ BEGIN perform mx_call_func_tbl(40); END; $$;
DEBUG: not pushing down function calls in a multi-statement transaction
SELECT * FROM mx_call_dist_table_1 WHERE id >= 40 ORDER BY id, val;
id | val
---------------------------------------------------------------------
@ -769,7 +762,6 @@ DEBUG: pushing down the function call
-- not delegated in a transaction block
BEGIN;
SELECT mx_call_func(2, 0);
DEBUG: not pushing down function calls in a multi-statement transaction
DEBUG: generating subplan XXX_1 for subquery SELECT sum((t1.val OPERATOR(pg_catalog.+) t2.val)) AS sum FROM (multi_mx_function_call_delegation.mx_call_dist_table_1 t1 JOIN multi_mx_function_call_delegation.mx_call_dist_table_2 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.id)))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT ((2 OPERATOR(pg_catalog.+) (SELECT intermediate_result.sum FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(sum bigint))))::integer
mx_call_func
@ -784,7 +776,6 @@ BEGIN
PERFORM mx_call_func(2, 0);
END;
$$ LANGUAGE plpgsql;
DEBUG: not pushing down function calls in a multi-statement transaction
DEBUG: generating subplan XXX_1 for subquery SELECT sum((t1.val OPERATOR(pg_catalog.+) t2.val)) AS sum FROM (multi_mx_function_call_delegation.mx_call_dist_table_1 t1 JOIN multi_mx_function_call_delegation.mx_call_dist_table_2 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.id)))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT ((2 OPERATOR(pg_catalog.+) (SELECT intermediate_result.sum FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(sum bigint))))::integer
-- forced calls are delegated in a transaction block

9
src/test/regress/expected/multi_mx_function_call_delegation_0.out
View File

@ -170,7 +170,6 @@ NOTICE: procedure multi_mx_function_call_delegation.squares is already distribu
-- colocated with any distributed tables.
SET client_min_messages TO DEBUG1;
select mx_call_func(2, 0);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT sum((t1.val OPERATOR(pg_catalog.+) t2.val)) AS sum FROM (multi_mx_function_call_delegation.mx_call_dist_table_1 t1 JOIN multi_mx_function_call_delegation.mx_call_dist_table_2 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.id)))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT (3 OPERATOR(pg_catalog.+) (SELECT intermediate_result.sum FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(sum bigint)))
mx_call_func
@ -179,14 +178,12 @@ DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT (3 OPERATOR(p
(1 row)
select multi_mx_function_call_delegation.mx_call_func_bigint(4, 2);
DEBUG: function does not have co-located tables
mx_call_func_bigint
---------------------------------------------------------------------
8
(1 row)
select mx_call_func_custom_types('S', 'A');
DEBUG: function does not have co-located tables
mx_call_func_custom_types
---------------------------------------------------------------------
(F,S)
@ -286,7 +283,6 @@ RESET citus.enable_binary_protocol;
-- We don't allow distributing calls inside transactions
begin;
select mx_call_func(2, 0);
DEBUG: not pushing down function calls in a multi-statement transaction
DEBUG: generating subplan XXX_1 for subquery SELECT sum((t1.val OPERATOR(pg_catalog.+) t2.val)) AS sum FROM (multi_mx_function_call_delegation.mx_call_dist_table_1 t1 JOIN multi_mx_function_call_delegation.mx_call_dist_table_2 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.id)))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT (3 OPERATOR(pg_catalog.+) (SELECT intermediate_result.sum FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(sum bigint)))
mx_call_func
@ -301,7 +297,6 @@ SET client_min_messages TO NOTICE;
drop table mx_call_dist_table_enum;
SET client_min_messages TO DEBUG1;
select mx_call_func_custom_types('S', 'A');
DEBUG: function does not have co-located tables
mx_call_func_custom_types
---------------------------------------------------------------------
(F,S)
@ -395,7 +390,6 @@ END;$$;
DEBUG: switching to sequential query execution mode
-- before distribution ...
select mx_call_func_tbl(10);
DEBUG: function does not have co-located tables
mx_call_func_tbl
---------------------------------------------------------------------
(10,-1)
@ -685,7 +679,6 @@ ERROR: cannot execute a distributed query from a query on a shard
select mx_call_func_copy(2) from mx_call_dist_table_1 where id = 3;
ERROR: cannot execute a distributed query from a query on a shard
DO $$ BEGIN perform mx_call_func_tbl(40); END; $$;
DEBUG: not pushing down function calls in a multi-statement transaction
SELECT * FROM mx_call_dist_table_1 WHERE id >= 40 ORDER BY id, val;
id | val
---------------------------------------------------------------------
@ -769,7 +762,6 @@ DEBUG: pushing down the function call
-- not delegated in a transaction block
BEGIN;
SELECT mx_call_func(2, 0);
DEBUG: not pushing down function calls in a multi-statement transaction
DEBUG: generating subplan XXX_1 for subquery SELECT sum((t1.val OPERATOR(pg_catalog.+) t2.val)) AS sum FROM (multi_mx_function_call_delegation.mx_call_dist_table_1 t1 JOIN multi_mx_function_call_delegation.mx_call_dist_table_2 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.id)))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT (2 OPERATOR(pg_catalog.+) (SELECT intermediate_result.sum FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(sum bigint)))
mx_call_func
@ -784,7 +776,6 @@ BEGIN
PERFORM mx_call_func(2, 0);
END;
$$ LANGUAGE plpgsql;
DEBUG: not pushing down function calls in a multi-statement transaction
DEBUG: generating subplan XXX_1 for subquery SELECT sum((t1.val OPERATOR(pg_catalog.+) t2.val)) AS sum FROM (multi_mx_function_call_delegation.mx_call_dist_table_1 t1 JOIN multi_mx_function_call_delegation.mx_call_dist_table_2 t2 ON ((t1.id OPERATOR(pg_catalog.=) t2.id)))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT (2 OPERATOR(pg_catalog.+) (SELECT intermediate_result.sum FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(sum bigint)))
-- forced calls are delegated in a transaction block

4
src/test/regress/expected/multi_router_planner.out
View File

@ -1653,7 +1653,6 @@ SELECT 1 FROM authors_reference r JOIN (
SELECT s.datid FROM number1() s LEFT JOIN pg_database d ON s.datid = d.oid
) num_db ON (r.id = num_db.datid) LIMIT 1;
DEBUG: found no worker with all shard placements
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT datid FROM multi_router_planner.number1() s(datid)
DEBUG: Creating router plan
DEBUG: generating subplan XXX_2 for subquery SELECT s.datid FROM ((SELECT intermediate_result.datid FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(datid integer)) s LEFT JOIN pg_database d ON (((s.datid)::oid OPERATOR(pg_catalog.=) d.oid)))
@ -1668,7 +1667,6 @@ CREATE VIEW num_db AS
SELECT s.datid FROM number1() s LEFT JOIN pg_database d ON s.datid = d.oid;
SELECT 1 FROM authors_reference r JOIN num_db ON (r.id = num_db.datid) LIMIT 1;
DEBUG: found no worker with all shard placements
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT datid FROM multi_router_planner.number1() s(datid)
DEBUG: Creating router plan
DEBUG: generating subplan XXX_2 for subquery SELECT s.datid FROM ((SELECT intermediate_result.datid FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(datid integer)) s LEFT JOIN pg_database d ON (((s.datid)::oid OPERATOR(pg_catalog.=) d.oid)))
@ -2422,7 +2420,6 @@ $$ LANGUAGE plpgsql;
DEBUG: switching to sequential query execution mode
DETAIL: A command for a distributed function is run. To make sure subsequent commands see the function correctly we need to make sure to use only one connection for all future commands
SELECT author_articles_max_id();
DEBUG: function does not have co-located tables
DEBUG: Creating router plan
CONTEXT: SQL statement "SELECT MAX(id) FROM articles_hash ah
WHERE author_id = 1"
@ -2450,7 +2447,6 @@ $$ LANGUAGE plpgsql;
DEBUG: switching to sequential query execution mode
DETAIL: A command for a distributed function is run. To make sure subsequent commands see the function correctly we need to make sure to use only one connection for all future commands
SELECT * FROM author_articles_id_word_count() ORDER BY 1;
DEBUG: function does not have co-located tables
DEBUG: Creating router plan
CONTEXT: SQL statement "SELECT ah.id, ah.word_count
FROM articles_hash ah

24
src/test/regress/expected/multi_router_planner_fast_path.out
View File

@ -1612,7 +1612,6 @@ DETAIL: A command for a distributed function is run. To make sure subsequent co
-- since the query results verifies the correctness
\set VERBOSITY terse
SELECT author_articles_max_id();
DEBUG: function does not have co-located tables
DEBUG: Distributed planning for a fast-path router query
DEBUG: Creating router plan
DEBUG: query has a single distribution column value: 1
@ -1622,35 +1621,30 @@ DEBUG: query has a single distribution column value: 1
(1 row)
SELECT author_articles_max_id();
DEBUG: function does not have co-located tables
author_articles_max_id
---------------------------------------------------------------------
41
(1 row)
SELECT author_articles_max_id();
DEBUG: function does not have co-located tables
author_articles_max_id
---------------------------------------------------------------------
41
(1 row)
SELECT author_articles_max_id();
DEBUG: function does not have co-located tables
author_articles_max_id
---------------------------------------------------------------------
41
(1 row)
SELECT author_articles_max_id();
DEBUG: function does not have co-located tables
author_articles_max_id
---------------------------------------------------------------------
41
(1 row)
SELECT author_articles_max_id();
DEBUG: function does not have co-located tables
author_articles_max_id
---------------------------------------------------------------------
41
@ -1669,7 +1663,6 @@ END;
$$ LANGUAGE plpgsql;
DEBUG: switching to sequential query execution mode
SELECT author_articles_max_id(1);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
DEBUG: Creating router plan
author_articles_max_id
@ -1678,7 +1671,6 @@ DEBUG: Creating router plan
(1 row)
SELECT author_articles_max_id(1);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
DEBUG: Creating router plan
author_articles_max_id
@ -1687,7 +1679,6 @@ DEBUG: Creating router plan
(1 row)
SELECT author_articles_max_id(1);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
DEBUG: Creating router plan
author_articles_max_id
@ -1696,7 +1687,6 @@ DEBUG: Creating router plan
(1 row)
SELECT author_articles_max_id(1);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
DEBUG: Creating router plan
author_articles_max_id
@ -1705,7 +1695,6 @@ DEBUG: Creating router plan
(1 row)
SELECT author_articles_max_id(1);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
DEBUG: Creating router plan
author_articles_max_id
@ -1714,7 +1703,6 @@ DEBUG: Creating router plan
(1 row)
SELECT author_articles_max_id(1);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
DEBUG: Creating router plan
author_articles_max_id
@ -1735,7 +1723,6 @@ END;
$$ LANGUAGE plpgsql;
DEBUG: switching to sequential query execution mode
SELECT * FROM author_articles_id_word_count();
DEBUG: function does not have co-located tables
DEBUG: Distributed planning for a fast-path router query
DEBUG: Creating router plan
DEBUG: query has a single distribution column value: 1
@ -1749,7 +1736,6 @@ DEBUG: query has a single distribution column value: 1
(5 rows)
SELECT * FROM author_articles_id_word_count();
DEBUG: function does not have co-located tables
id | word_count
---------------------------------------------------------------------
1 | 9572
@ -1760,7 +1746,6 @@ DEBUG: function does not have co-located tables
(5 rows)
SELECT * FROM author_articles_id_word_count();
DEBUG: function does not have co-located tables
id | word_count
---------------------------------------------------------------------
1 | 9572
@ -1771,7 +1756,6 @@ DEBUG: function does not have co-located tables
(5 rows)
SELECT * FROM author_articles_id_word_count();
DEBUG: function does not have co-located tables
id | word_count
---------------------------------------------------------------------
1 | 9572
@ -1782,7 +1766,6 @@ DEBUG: function does not have co-located tables
(5 rows)
SELECT * FROM author_articles_id_word_count();
DEBUG: function does not have co-located tables
id | word_count
---------------------------------------------------------------------
1 | 9572
@ -1793,7 +1776,6 @@ DEBUG: function does not have co-located tables
(5 rows)
SELECT * FROM author_articles_id_word_count();
DEBUG: function does not have co-located tables
id | word_count
---------------------------------------------------------------------
1 | 9572
@ -1816,7 +1798,6 @@ END;
$$ LANGUAGE plpgsql;
DEBUG: switching to sequential query execution mode
SELECT * FROM author_articles_id_word_count(1);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
DEBUG: Creating router plan
id | word_count
@ -1829,7 +1810,6 @@ DEBUG: Creating router plan
(5 rows)
SELECT * FROM author_articles_id_word_count(1);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
DEBUG: Creating router plan
id | word_count
@ -1842,7 +1822,6 @@ DEBUG: Creating router plan
(5 rows)
SELECT * FROM author_articles_id_word_count(1);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
DEBUG: Creating router plan
id | word_count
@ -1855,7 +1834,6 @@ DEBUG: Creating router plan
(5 rows)
SELECT * FROM author_articles_id_word_count(1);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
DEBUG: Creating router plan
id | word_count
@ -1868,7 +1846,6 @@ DEBUG: Creating router plan
(5 rows)
SELECT * FROM author_articles_id_word_count(1);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
DEBUG: Creating router plan
id | word_count
@ -1881,7 +1858,6 @@ DEBUG: Creating router plan
(5 rows)
SELECT * FROM author_articles_id_word_count(1);
DEBUG: function does not have co-located tables
DEBUG: Deferred pruning for a fast-path router query
DEBUG: Creating router plan
id | word_count

7
src/test/regress/expected/non_colocated_leaf_subquery_joins.out
View File

@ -37,7 +37,6 @@ FROM
(SELECT users_table.user_id FROM users_table, events_table WHERE users_table.user_id = events_table.user_id AND event_type IN (5,6,7,8)) as bar
WHERE
foo.user_id = bar.user_id;$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id, random() AS random FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM (SELECT intermediate_result.user_id, intermediate_result.random FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer, random double precision)) foo, (SELECT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))) bar WHERE (foo.user_id OPERATOR(pg_catalog.=) bar.user_id)
valid
@ -53,7 +52,6 @@ FROM
(SELECT users_table.user_id FROM users_table, events_table WHERE users_table.user_id = events_table.value_2 AND event_type IN (5,6,7,8)) as bar
WHERE
foo.user_id = bar.user_id;$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id, random() AS random FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))
DEBUG: generating subplan XXX_2 for subquery SELECT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM (SELECT intermediate_result.user_id, intermediate_result.random FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer, random double precision)) foo, (SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_2'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)) bar WHERE (foo.user_id OPERATOR(pg_catalog.=) bar.user_id)
@ -76,7 +74,6 @@ WHERE
users_table, events_table
WHERE
users_table.user_id = events_table.value_2 AND event_type IN (5,6));$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6])))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM public.users_table WHERE (value_1 OPERATOR(pg_catalog.=) ANY (SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)))
valid
@ -93,7 +90,6 @@ SELECT count(*) FROM q1, (SELECT
users_table, events_table
WHERE
users_table.user_id = events_table.value_2 AND event_type IN (1,2,3,4)) as bar WHERE bar.user_id = q1.user_id ;$$);
DEBUG: function does not have co-located tables
DEBUG: CTE q1 is going to be inlined via distributed planning
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id, random() AS random FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM (SELECT users_table.user_id FROM public.users_table) q1, (SELECT intermediate_result.user_id, intermediate_result.random FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer, random double precision)) bar WHERE (bar.user_id OPERATOR(pg_catalog.=) q1.user_id)
@ -106,7 +102,6 @@ DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS c
SELECT true AS valid FROM explain_json($$
(SELECT users_table.user_id FROM users_table, events_table WHERE users_table.user_id = events_table.value_2 AND event_type IN (1,2,3,4)) UNION
(SELECT users_table.user_id FROM users_table, events_table WHERE users_table.user_id = events_table.user_id AND event_type IN (5,6,7,8));$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))
DEBUG: generating subplan XXX_2 for subquery SELECT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer) UNION SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_2'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)
@ -143,7 +138,6 @@ FROM (
) q
ORDER BY 2 DESC, 1;
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))
DEBUG: push down of limit count: 5
DEBUG: generating subplan XXX_2 for subquery SELECT user_id FROM public.users_table WHERE ((value_2 OPERATOR(pg_catalog.>=) 5) AND (EXISTS (SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)))) LIMIT 5
@ -165,7 +159,6 @@ FROM
(SELECT users_table.user_id, value_1 FROM users_table, events_table WHERE users_table.user_id = events_table.user_id AND event_type IN (5,6,7,8)) as bar
WHERE
foo.user_id = bar.value_1;$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM (SELECT users_table.user_id, random() AS random FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))) foo, (SELECT intermediate_result.user_id, intermediate_result.value_1 FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer, value_1 integer)) bar WHERE (foo.user_id OPERATOR(pg_catalog.=) bar.value_1)
valid

37
src/test/regress/expected/non_colocated_subquery_joins.out
View File

@ -44,7 +44,6 @@ SELECT true AS valid FROM explain_json_2($$
WHERE
foo.value_2 = bar.value_2;
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.value_2 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT foo.value_2 FROM (SELECT users_table.value_2 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))) foo, (SELECT intermediate_result.value_2 FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(value_2 integer)) bar WHERE (foo.value_2 OPERATOR(pg_catalog.=) bar.value_2)
valid
@ -65,7 +64,6 @@ SELECT true AS valid FROM explain_json_2($$
(SELECT event_type FROM events_table WHERE user_id < 100);
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT event_type FROM public.events_table WHERE (user_id OPERATOR(pg_catalog.<) 100)
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM public.events_table WHERE (event_type OPERATOR(pg_catalog.=) ANY (SELECT intermediate_result.event_type FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(event_type integer)))
valid
@ -85,7 +83,6 @@ SELECT true AS valid FROM explain_json_2($$
NOT IN
(SELECT user_id FROM events_table WHERE event_type = 2);
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT user_id FROM public.events_table WHERE (event_type OPERATOR(pg_catalog.=) 2)
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM public.events_table WHERE (NOT (user_id OPERATOR(pg_catalog.=) ANY (SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer))))
valid
@ -107,7 +104,6 @@ SELECT true AS valid FROM explain_json_2($$
foo.event_type IN (SELECT event_type FROM events_table WHERE user_id < 3);
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT event_type FROM public.events_table WHERE (user_id OPERATOR(pg_catalog.<) 3)
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT foo.user_id FROM (SELECT users_table.user_id, events_table.event_type FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))) foo, (SELECT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))) bar WHERE ((foo.user_id OPERATOR(pg_catalog.=) bar.user_id) AND (foo.event_type OPERATOR(pg_catalog.=) ANY (SELECT intermediate_result.event_type FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(event_type integer))))
valid
@ -128,7 +124,6 @@ SELECT true AS valid FROM explain_json_2($$
foo.user_id = bar.user_id AND
foo.user_id IN (SELECT user_id FROM events_table WHERE user_id < 10);
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT (users_table.user_id OPERATOR(pg_catalog./) 2) AS user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT foo.user_id FROM (SELECT users_table.user_id, events_table.event_type FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))) foo, (SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)) bar WHERE ((foo.user_id OPERATOR(pg_catalog.=) bar.user_id) AND (foo.user_id OPERATOR(pg_catalog.=) ANY (SELECT events_table.user_id FROM public.events_table WHERE (events_table.user_id OPERATOR(pg_catalog.<) 10))))
valid
@ -149,7 +144,6 @@ SELECT true AS valid FROM explain_json_2($$
foo.user_id = bar.user_id AND
foo.user_id NOT IN (SELECT user_id FROM events_table WHERE user_id < 10);
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT (users_table.user_id OPERATOR(pg_catalog./) 2) AS user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))
DEBUG: generating subplan XXX_2 for subquery SELECT user_id FROM public.events_table WHERE (user_id OPERATOR(pg_catalog.<) 10)
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT foo.user_id FROM (SELECT users_table.user_id, events_table.event_type FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))) foo, (SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)) bar WHERE ((foo.user_id OPERATOR(pg_catalog.=) bar.user_id) AND (NOT (foo.user_id OPERATOR(pg_catalog.=) ANY (SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_2'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)))))
@ -171,7 +165,6 @@ SELECT true AS valid FROM explain_json_2($$
foo.user_id = bar.user_id AND
foo.event_type IN (SELECT event_type FROM events_table WHERE user_id < 4);
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id, events_table.event_type FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))
DEBUG: generating subplan XXX_2 for subquery SELECT event_type FROM public.events_table WHERE (user_id OPERATOR(pg_catalog.<) 4)
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT foo.user_id FROM (SELECT intermediate_result.user_id, intermediate_result.event_type FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer, event_type integer)) foo, (SELECT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))) bar WHERE ((foo.user_id OPERATOR(pg_catalog.=) bar.user_id) AND (foo.event_type OPERATOR(pg_catalog.=) ANY (SELECT intermediate_result.event_type FROM read_intermediate_result('XXX_2'::text, 'binary'::citus_copy_format) intermediate_result(event_type integer))))
@ -196,7 +189,6 @@ SELECT true AS valid FROM explain_json_2($$
) as foo_top, events_table WHERE events_table.user_id = foo_top.user_id;
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id, events_table.event_type FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))
DEBUG: generating subplan XXX_2 for subquery SELECT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.event_type) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))
DEBUG: generating subplan XXX_3 for subquery SELECT event_type FROM public.events_table WHERE (user_id OPERATOR(pg_catalog.=) 5)
@ -231,7 +223,6 @@ SELECT true AS valid FROM explain_json_2($$
) as foo_top;
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[17, 18, 19, 20])))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT user_id, random FROM (SELECT foo1.user_id, random() AS random FROM (SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))) foo1, (SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))) foo2, (SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[9, 10, 11, 12])))) foo3, (SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[13, 14, 15, 16])))) foo4, (SELECT intermediate_result.user_id, intermediate_result.value_1 FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer, value_1 integer)) foo5 WHERE ((foo1.user_id OPERATOR(pg_catalog.=) foo4.user_id) AND (foo1.user_id OPERATOR(pg_catalog.=) foo2.user_id) AND (foo1.user_id OPERATOR(pg_catalog.=) foo3.user_id) AND (foo1.user_id OPERATOR(pg_catalog.=) foo4.user_id) AND (foo1.user_id OPERATOR(pg_catalog.=) foo5.value_1))) foo_top
valid
@ -263,7 +254,6 @@ SELECT true AS valid FROM explain_json_2($$
foo1.user_id = foo5.user_id
) as foo_top;
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[17, 18, 19, 20])))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT user_id, random FROM (SELECT foo1.user_id, random() AS random FROM (SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))) foo1, (SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))) foo2, (SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[9, 10, 11, 12])))) foo3, (SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[13, 14, 15, 16])))) foo4, (SELECT intermediate_result.user_id, intermediate_result.value_1 FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer, value_1 integer)) foo5 WHERE ((foo1.user_id OPERATOR(pg_catalog.=) foo4.user_id) AND (foo1.user_id OPERATOR(pg_catalog.=) foo2.user_id) AND (foo1.user_id OPERATOR(pg_catalog.=) foo3.user_id) AND (foo1.user_id OPERATOR(pg_catalog.=) foo4.user_id) AND (foo1.user_id OPERATOR(pg_catalog.=) foo5.user_id))) foo_top
valid
@ -293,7 +283,6 @@ SELECT true AS valid FROM explain_json_2($$
foo1.user_id = foo5.value_1
) as foo_top;
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))
DEBUG: generating subplan XXX_2 for subquery SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[17, 18, 19, 20])))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT user_id, random FROM (SELECT foo1.user_id, random() AS random FROM (SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))) foo1, (SELECT intermediate_result.user_id, intermediate_result.value_1 FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer, value_1 integer)) foo2, (SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[9, 10, 11, 12])))) foo3, (SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[13, 14, 15, 16])))) foo4, (SELECT intermediate_result.user_id, intermediate_result.value_1 FROM read_intermediate_result('XXX_2'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer, value_1 integer)) foo5 WHERE ((foo1.user_id OPERATOR(pg_catalog.=) foo4.user_id) AND (foo1.user_id OPERATOR(pg_catalog.=) foo2.user_id) AND (foo1.user_id OPERATOR(pg_catalog.=) foo3.user_id) AND (foo1.user_id OPERATOR(pg_catalog.=) foo4.user_id) AND (foo1.user_id OPERATOR(pg_catalog.=) foo5.value_1))) foo_top
@ -325,7 +314,6 @@ SELECT true AS valid FROM explain_json_2($$
foo2.user_id = foo5.value_1
) as foo_top;
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))
DEBUG: generating subplan XXX_2 for subquery SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[17, 18, 19, 20])))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT user_id, random FROM (SELECT foo1.user_id, random() AS random FROM (SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))) foo1, (SELECT intermediate_result.user_id, intermediate_result.value_1 FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer, value_1 integer)) foo2, (SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[9, 10, 11, 12])))) foo3, (SELECT users_table.user_id, users_table.value_1 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[13, 14, 15, 16])))) foo4, (SELECT intermediate_result.user_id, intermediate_result.value_1 FROM read_intermediate_result('XXX_2'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer, value_1 integer)) foo5 WHERE ((foo1.user_id OPERATOR(pg_catalog.=) foo4.user_id) AND (foo1.user_id OPERATOR(pg_catalog.=) foo2.user_id) AND (foo1.user_id OPERATOR(pg_catalog.=) foo3.user_id) AND (foo1.user_id OPERATOR(pg_catalog.=) foo4.user_id) AND (foo2.user_id OPERATOR(pg_catalog.=) foo5.value_1))) foo_top
@ -359,7 +347,6 @@ SELECT true AS valid FROM explain_json_2($$
foo.user_id = bar.user_id) as bar_top
ON (foo_top.user_id = bar_top.user_id);
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))
DEBUG: generating subplan XXX_2 for subquery SELECT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM ((SELECT foo.user_id FROM (SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)) foo, (SELECT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))) bar WHERE (foo.user_id OPERATOR(pg_catalog.=) bar.user_id)) foo_top JOIN (SELECT foo.user_id FROM (SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_2'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)) foo, (SELECT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))) bar WHERE (foo.user_id OPERATOR(pg_catalog.=) bar.user_id)) bar_top ON ((foo_top.user_id OPERATOR(pg_catalog.=) bar_top.user_id)))
@ -394,7 +381,6 @@ SELECT true AS valid FROM explain_json_2($$
ON (foo_top.value_2 = bar_top.user_id);
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT foo.user_id FROM (SELECT DISTINCT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[9, 10, 11, 12])))) foo, (SELECT DISTINCT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[13, 14, 15, 16])))) bar WHERE (foo.user_id OPERATOR(pg_catalog.=) bar.user_id)
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM ((SELECT foo.user_id, foo.value_2 FROM (SELECT DISTINCT users_table.user_id, users_table.value_2 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))) foo, (SELECT DISTINCT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))) bar WHERE (foo.user_id OPERATOR(pg_catalog.=) bar.user_id)) foo_top JOIN (SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)) bar_top ON ((foo_top.value_2 OPERATOR(pg_catalog.=) bar_top.user_id)))
valid
@ -426,7 +412,6 @@ SELECT true AS valid FROM explain_json_2($$
foo.user_id = bar.user_id) as bar_top
ON (foo_top.value_2 = bar_top.user_id);
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT DISTINCT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[13, 14, 15, 16])))
DEBUG: generating subplan XXX_2 for subquery SELECT foo.user_id FROM (SELECT DISTINCT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[9, 10, 11, 12])))) foo, (SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)) bar WHERE (foo.user_id OPERATOR(pg_catalog.=) bar.user_id)
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM ((SELECT foo.user_id, foo.value_2 FROM (SELECT DISTINCT users_table.user_id, users_table.value_2 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))) foo, (SELECT DISTINCT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))) bar WHERE (foo.user_id OPERATOR(pg_catalog.=) bar.user_id)) foo_top JOIN (SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_2'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)) bar_top ON ((foo_top.value_2 OPERATOR(pg_catalog.=) bar_top.user_id)))
@ -448,7 +433,6 @@ SELECT true AS valid FROM explain_json_2($$
WHERE foo.my_users = users_table.user_id) as mid_level_query
) as bar;
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT events_table.user_id AS my_users FROM public.events_table, public.users_table WHERE (events_table.event_type OPERATOR(pg_catalog.=) users_table.user_id)
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM (SELECT mid_level_query.user_id FROM (SELECT DISTINCT users_table.user_id FROM public.users_table, (SELECT intermediate_result.my_users FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(my_users integer)) foo WHERE (foo.my_users OPERATOR(pg_catalog.=) users_table.user_id)) mid_level_query) bar
valid
@ -468,7 +452,6 @@ SELECT true AS valid FROM explain_json_2($$
WHERE foo.my_users = users_table.user_id) as mid_level_query ) as bar;
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT events_table.event_type AS my_users, random() AS random FROM public.events_table, public.users_table WHERE (events_table.user_id OPERATOR(pg_catalog.=) users_table.user_id)
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM (SELECT mid_level_query.user_id FROM (SELECT DISTINCT users_table.user_id FROM public.users_table, (SELECT intermediate_result.my_users, intermediate_result.random FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(my_users integer, random double precision)) foo WHERE (foo.my_users OPERATOR(pg_catalog.=) users_table.user_id)) mid_level_query) bar
valid
@ -492,7 +475,6 @@ DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS c
WHERE foo.my_users = users_table.user_id) as mid_level_query
) as bar;
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT events_table.user_id, random() AS random FROM public.users_table, public.events_table WHERE (users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id)
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM (SELECT mid_level_query.user_id FROM (SELECT DISTINCT users_table.user_id FROM public.users_table, (SELECT events_table.user_id AS my_users FROM public.events_table, (SELECT intermediate_result.user_id, intermediate_result.random FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer, random double precision)) selected_users WHERE (events_table.event_type OPERATOR(pg_catalog.=) selected_users.user_id)) foo WHERE (foo.my_users OPERATOR(pg_catalog.=) users_table.user_id)) mid_level_query) bar
valid
@ -526,7 +508,6 @@ SELECT true AS valid FROM explain_json_2($$
) as bar;
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT value_2 FROM public.events_table
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM (SELECT mid_level_query.user_id FROM (SELECT DISTINCT users_table.user_id FROM public.users_table, (SELECT events_table.user_id AS my_users FROM public.events_table, (SELECT events_table_1.user_id FROM public.users_table users_table_1, public.events_table events_table_1 WHERE ((users_table_1.user_id OPERATOR(pg_catalog.=) events_table_1.user_id) AND (users_table_1.user_id OPERATOR(pg_catalog.=) ANY (SELECT intermediate_result.value_2 FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(value_2 integer))))) selected_users WHERE (events_table.user_id OPERATOR(pg_catalog.=) selected_users.user_id)) foo WHERE (foo.my_users OPERATOR(pg_catalog.=) users_table.user_id)) mid_level_query) bar
valid
@ -548,7 +529,6 @@ WHERE
users_table, events_table
WHERE
users_table.user_id = events_table.value_2 AND event_type IN (5,6));$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6])))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM public.users_table WHERE (value_1 OPERATOR(pg_catalog.=) ANY (SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)))
valid
@ -565,7 +545,6 @@ SELECT count(*) FROM q1, (SELECT
users_table, events_table
WHERE
users_table.user_id = events_table.value_2 AND event_type IN (1,2,3,4)) as bar WHERE bar.user_id = q1.user_id ;$$);
DEBUG: function does not have co-located tables
DEBUG: CTE q1 is going to be inlined via distributed planning
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id, random() AS random FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM (SELECT users_table.user_id FROM public.users_table) q1, (SELECT intermediate_result.user_id, intermediate_result.random FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer, random double precision)) bar WHERE (bar.user_id OPERATOR(pg_catalog.=) q1.user_id)
@ -583,7 +562,6 @@ SELECT true AS valid FROM explain_json_2($$
users_table, events_table
WHERE
users_table.user_id = events_table.user_id AND event_type IN (1,2,3,4)) as bar WHERE bar.user_id = q1.user_id ;$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for CTE q1: SELECT user_id FROM public.users_table
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM (SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)) q1, (SELECT users_table.user_id, random() AS random FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))) bar WHERE (bar.user_id OPERATOR(pg_catalog.=) q1.user_id)
valid
@ -595,7 +573,6 @@ DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS c
SELECT true AS valid FROM explain_json_2($$
(SELECT users_table.user_id FROM users_table, events_table WHERE users_table.user_id = events_table.value_2 AND event_type IN (1,2,3,4)) UNION
(SELECT users_table.user_id FROM users_table, events_table WHERE users_table.user_id = events_table.user_id AND event_type IN (5,6,7,8));$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))
DEBUG: generating subplan XXX_2 for subquery SELECT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer) UNION SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_2'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)
@ -632,7 +609,6 @@ FROM (
) q
ORDER BY 2 DESC, 1;
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.user_id FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.value_2) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))
DEBUG: push down of limit count: 5
DEBUG: generating subplan XXX_2 for subquery SELECT user_id FROM public.users_table WHERE ((value_2 OPERATOR(pg_catalog.>=) 5) AND (EXISTS (SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)))) LIMIT 5
@ -654,7 +630,6 @@ SELECT true AS valid FROM explain_json_2($$
FROM
(users_table u1 JOIN users_table u2 using(value_1)) a JOIN (SELECT value_1, random() FROM users_table) as u3 USING (value_1);
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT value_1, random() AS random FROM public.users_table
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM ((public.users_table u1 JOIN public.users_table u2 USING (value_1)) a(value_1, user_id, "time", value_2, value_3, value_4, user_id_1, time_1, value_2_1, value_3_1, value_4_1) JOIN (SELECT intermediate_result.value_1, intermediate_result.random FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(value_1 integer, random double precision)) u3 USING (value_1))
ERROR: complex joins are only supported when all distributed tables are co-located and joined on their distribution columns
@ -667,7 +642,6 @@ SELECT true AS valid FROM explain_json_2($$
FROM
(SELECT * FROM users_table u1 JOIN users_table u2 using(value_1)) a JOIN (SELECT value_1, random() FROM users_table) as u3 USING (value_1);
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT u1.value_1, u1.user_id, u1."time", u1.value_2, u1.value_3, u1.value_4, u2.user_id, u2."time", u2.value_2, u2.value_3, u2.value_4 FROM (public.users_table u1 JOIN public.users_table u2 USING (value_1))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM ((SELECT intermediate_result.value_1, intermediate_result.user_id, intermediate_result."time", intermediate_result.value_2, intermediate_result.value_3, intermediate_result.value_4, intermediate_result.user_id_1 AS user_id, intermediate_result.time_1 AS "time", intermediate_result.value_2_1 AS value_2, intermediate_result.value_3_1 AS value_3, intermediate_result.value_4_1 AS value_4 FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(value_1 integer, user_id integer, "time" timestamp without time zone, value_2 integer, value_3 double precision, value_4 bigint, user_id_1 integer, time_1 timestamp without time zone, value_2_1 integer, value_3_1 double precision, value_4_1 bigint)) a(value_1, user_id, "time", value_2, value_3, value_4, user_id_1, time_1, value_2_1, value_3_1, value_4_1) JOIN (SELECT users_table.value_1, random() AS random FROM public.users_table) u3 USING (value_1))
valid
@ -687,7 +661,6 @@ SELECT true AS valid FROM explain_json_2($$
events_table
using (value_2);
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT value_2, random() AS random FROM public.users_table
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM ((SELECT intermediate_result.value_2, intermediate_result.random FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(value_2 integer, random double precision)) u1 JOIN public.events_table USING (value_2))
valid
@ -706,7 +679,6 @@ SELECT true AS valid FROM explain_json_2($$
(SELECT value_2, random() FROM users_table) as u2
USING(value_2);
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT value_2, random() AS random FROM public.users_table
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM ((SELECT users_table.value_2, random() AS random FROM public.users_table) u1 LEFT JOIN (SELECT intermediate_result.value_2, intermediate_result.random FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(value_2 integer, random double precision)) u2 USING (value_2))
valid
@ -725,7 +697,6 @@ SELECT true AS valid FROM explain_json_2($$
(SELECT value_2, random() FROM users_table) as u2
USING(value_2);
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT value_2, random() AS random FROM public.users_table
DEBUG: recursively planning left side of the right join since the outer side is a recurring rel
DEBUG: recursively planning the distributed subquery since it is part of a distributed join node that is outer joined with a recurring rel
@ -752,7 +723,6 @@ SELECT true AS valid FROM explain_json_2($$
(SELECT value_1 FROM users_table) as foo ON (a.user_id = foo.value_1)
);
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT user_id FROM public.users_table
DEBUG: generating subplan XXX_2 for subquery SELECT user_id FROM public.users_table
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer) UNION SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_2'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)
@ -777,7 +747,6 @@ SELECT true AS valid FROM explain_json_2($$
users_table as foo ON (a.user_id = foo.value_1)
);
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT user_id FROM public.users_table
DEBUG: generating subplan XXX_2 for subquery SELECT user_id FROM public.users_table
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer) UNION SELECT intermediate_result.user_id FROM read_intermediate_result('XXX_2'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer)
@ -811,7 +780,6 @@ SELECT true AS valid FROM explain_json_2($$
ON(foo.user_id = bar.value_1)
);
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT value_1 FROM public.users_table
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT foo.user_id, a.user_id, bar.value_1 FROM (((SELECT users_table.user_id FROM public.users_table) foo JOIN (SELECT users_table.user_id FROM public.users_table WHERE (users_table.user_id OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])) UNION SELECT users_table.user_id FROM public.users_table WHERE (users_table.user_id OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8]))) a ON ((a.user_id OPERATOR(pg_catalog.=) foo.user_id))) JOIN (SELECT intermediate_result.value_1 FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(value_1 integer)) bar ON ((foo.user_id OPERATOR(pg_catalog.=) bar.value_1)))
valid
@ -851,7 +819,6 @@ SELECT true AS valid FROM explain_json_2($$
WHERE
non_colocated_subquery.value_2 != non_colocated_subquery_2.cnt
$$);
DEBUG: function does not have co-located tables
DEBUG: CTE non_colocated_subquery is going to be inlined via distributed planning
DEBUG: CTE non_colocated_subquery_2 is going to be inlined via distributed planning
DEBUG: generating subplan XXX_1 for subquery SELECT users_table.value_2 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))
@ -876,7 +843,6 @@ SELECT true AS valid FROM explain_json_2($$
AND
foo.value_2 = baz.value_2
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT users_table_local.value_2 FROM non_colocated_subquery.users_table_local, non_colocated_subquery.events_table_local WHERE ((users_table_local.user_id OPERATOR(pg_catalog.=) events_table_local.user_id) AND (events_table_local.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[5, 6, 7, 8])))
DEBUG: generating subplan XXX_2 for subquery SELECT users_table.value_2 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[9, 10, 11, 12])))
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM (SELECT users_table.value_2 FROM public.users_table, public.events_table WHERE ((users_table.user_id OPERATOR(pg_catalog.=) events_table.user_id) AND (events_table.event_type OPERATOR(pg_catalog.=) ANY (ARRAY[1, 2, 3, 4])))) foo, (SELECT intermediate_result.value_2 FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(value_2 integer)) bar, (SELECT intermediate_result.value_2 FROM read_intermediate_result('XXX_2'::text, 'binary'::citus_copy_format) intermediate_result(value_2 integer)) baz WHERE ((foo.value_2 OPERATOR(pg_catalog.=) bar.value_2) AND (foo.value_2 OPERATOR(pg_catalog.=) baz.value_2))
@ -912,7 +878,6 @@ SELECT true AS valid FROM explain_json_2($$
AND
foo.user_id IN (SELECT users_table.user_id FROM users_table, events_table WHERE users_table.user_id = events_table.user_id AND event_type IN (1,2))
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT value_1, value_2 FROM public.users_table
DEBUG: generating subplan XXX_2 for subquery SELECT value_1 FROM public.users_table WHERE (value_2 OPERATOR(pg_catalog.<) 1)
DEBUG: generating subplan XXX_3 for subquery SELECT value_2 FROM public.users_table WHERE (value_1 OPERATOR(pg_catalog.<) 2)
@ -935,7 +900,6 @@ SELECT true AS valid FROM explain_json_2($$
users_table_ref.user_id = foo.user_id
AND foo.user_id = bar.value_2;
$$);
DEBUG: function does not have co-located tables
DEBUG: generating subplan XXX_1 for subquery SELECT user_id, value_2 FROM public.events_table
DEBUG: Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM public.users_reference_table users_table_ref, (SELECT users_table.user_id FROM public.users_table) foo, (SELECT intermediate_result.user_id, intermediate_result.value_2 FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(user_id integer, value_2 integer)) bar WHERE ((users_table_ref.user_id OPERATOR(pg_catalog.=) foo.user_id) AND (foo.user_id OPERATOR(pg_catalog.=) bar.value_2))
valid
@ -984,7 +948,6 @@ JOIN LATERAL
WHERE user_id = users_table.user_id) AS bar
LEFT JOIN users_table u2 ON u2.user_id = bar.value_2) AS foo ON TRUE
$$);
DEBUG: function does not have co-located tables
DEBUG: Router planner cannot handle multi-shard select queries
DEBUG: skipping recursive planning for the subquery since it contains references to outer queries
DEBUG: skipping recursive planning for the subquery since it contains references to outer queries

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

@ -59,6 +59,8 @@ BEGIN
END;
$$;
SELECT create_distributed_function('notice(text)');
NOTICE: procedure single_node_ent.notice is already distributed
DETAIL: Citus distributes procedures with CREATE [PROCEDURE|FUNCTION|AGGREGATE] commands
create_distributed_function
---------------------------------------------------------------------

1
src/test/regress/expected/subquery_and_cte.out
View File

@ -126,7 +126,6 @@ WITH cte1 AS MATERIALIZED (SELECT id, value FROM func())
UPDATE dist_table dt SET value = cte1.value
FROM cte1 WHERE dt.id = 1;
DEBUG: generating subplan XXX_1 for CTE cte1: SELECT id, value FROM subquery_and_ctes.func() func(id, value)
DEBUG: function does not have co-located tables
DEBUG: Plan XXX query after replacing subqueries and CTEs: UPDATE subquery_and_ctes.dist_table dt SET value = cte1.value FROM (SELECT intermediate_result.id, intermediate_result.value FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(id integer, value integer)) cte1 WHERE (dt.id OPERATOR(pg_catalog.=) 1)
-- CTEs are recursively planned, and subquery foo is also recursively planned
-- final plan becomes a real-time plan since we also have events_table in the

9
src/test/regress/spec/isolation_extension_commands.spec
View File

@ -41,13 +41,18 @@ step "s1-create-extension-with-schema2"
step "s1-print"
{
select count(*) from pg_catalog.pg_dist_object ;
select pg_identify_object_as_address(classid, objid, objsubid)::text as obj_repr from pg_dist_object order by obj_repr;
select extname, extversion, nspname from pg_extension, pg_namespace where pg_namespace.oid=pg_extension.extnamespace and extname='seg';
SELECT run_command_on_workers($$select extname from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select extversion from pg_extension where extname='seg'$$);
SELECT run_command_on_workers($$select nspname from pg_extension, pg_namespace where extname='seg' and pg_extension.extnamespace=pg_namespace.oid$$);
}
step "s1-cleanup-node-1"
{
SELECT run_command_on_workers($$drop extension if exists seg$$);
}
session "s2"
step "s2-begin"
@ -121,4 +126,4 @@ permutation "s2-add-node-1" "s2-begin" "s2-drop-extension" "s1-remove-node-1" "s
permutation "s2-begin" "s2-create-extension-with-schema1" "s1-add-node-1" "s2-commit" "s1-print"
permutation "s2-drop-extension" "s2-add-node-1" "s2-create-extension-with-schema2" "s2-begin" "s2-alter-extension-version-13" "s1-remove-node-1" "s2-commit" "s1-print"
permutation "s2-drop-extension" "s2-add-node-1" "s2-begin" "s2-create-extension-version-11" "s1-remove-node-1" "s2-commit" "s1-print"
permutation "s2-drop-extension" "s2-add-node-1" "s2-create-extension-version-11" "s2-remove-node-1" "s2-begin" "s2-drop-extension" "s1-add-node-1" "s2-commit" "s1-print"
permutation "s2-drop-extension" "s2-add-node-1" "s2-create-extension-version-11" "s2-remove-node-1" "s2-begin" "s2-drop-extension" "s1-add-node-1" "s2-commit" "s1-print" "s1-cleanup-node-1"

9
src/test/regress/sql/multi_drop_extension.sql
View File

@ -34,8 +34,13 @@ BEGIN;
alter table other_schema.l3 add constraint fkey foreign key (a) references l1(a);
-- show that works fine
drop schema public cascade;
-- Commented out because it fails due to the issue documented in
-- https://github.com/citusdata/citus/issues/6901.
--
-- This wasn't the case before https://github.com/citusdata/citus/pull/6900.
-- This is because, we were not marking the schemas as distributed when there
-- are no worker nodes in the cluster before that PR.
-- drop schema public cascade;
ROLLBACK;
CREATE EXTENSION citus;