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

fix typo in dependent jobs and dependent task (#3244)

pull/3243/head
SaitTalhaNisanci 2019-11-28 23:47:28 +03:00 committed by GitHub
parent ec9392e729
commit aeec3d1544
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 202 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/backend/distributed/commands/call.c
View File

@ -169,7 +169,7 @@ CallFuncExprRemotely(CallStmt *callStmt, DistObjectCacheEntry *procedure,
task->taskType = DDL_TASK; task->taskType = DDL_TASK;
task->queryString = callCommand->data; task->queryString = callCommand->data;
task->replicationModel = REPLICATION_MODEL_INVALID; task->replicationModel = REPLICATION_MODEL_INVALID;
task->dependedTaskList = NIL; task->dependentTaskList = NIL;
task->anchorShardId = placement->shardId; task->anchorShardId = placement->shardId;
task->relationShardList = NIL; task->relationShardList = NIL;
task->taskPlacementList = placementList; task->taskPlacementList = placementList;

6
src/backend/distributed/commands/index.c
View File

@ -523,7 +523,7 @@ CreateIndexTaskList(Oid relationId, IndexStmt *indexStmt)
task->taskType = DDL_TASK; task->taskType = DDL_TASK;
task->queryString = pstrdup(ddlString.data); task->queryString = pstrdup(ddlString.data);
task->replicationModel = REPLICATION_MODEL_INVALID; task->replicationModel = REPLICATION_MODEL_INVALID;
task->dependedTaskList = NULL; task->dependentTaskList = NULL;
task->anchorShardId = shardId; task->anchorShardId = shardId;
task->taskPlacementList = FinalizedShardPlacementList(shardId); task->taskPlacementList = FinalizedShardPlacementList(shardId);
@ -568,7 +568,7 @@ CreateReindexTaskList(Oid relationId, ReindexStmt *reindexStmt)
task->taskType = DDL_TASK; task->taskType = DDL_TASK;
task->queryString = pstrdup(ddlString.data); task->queryString = pstrdup(ddlString.data);
task->replicationModel = REPLICATION_MODEL_INVALID; task->replicationModel = REPLICATION_MODEL_INVALID;
task->dependedTaskList = NULL; task->dependentTaskList = NULL;
task->anchorShardId = shardId; task->anchorShardId = shardId;
task->taskPlacementList = FinalizedShardPlacementList(shardId); task->taskPlacementList = FinalizedShardPlacementList(shardId);
@ -898,7 +898,7 @@ DropIndexTaskList(Oid relationId, Oid indexId, DropStmt *dropStmt)
task->taskType = DDL_TASK; task->taskType = DDL_TASK;
task->queryString = pstrdup(ddlString.data); task->queryString = pstrdup(ddlString.data);
task->replicationModel = REPLICATION_MODEL_INVALID; task->replicationModel = REPLICATION_MODEL_INVALID;
task->dependedTaskList = NULL; task->dependentTaskList = NULL;
task->anchorShardId = shardId; task->anchorShardId = shardId;
task->taskPlacementList = FinalizedShardPlacementList(shardId); task->taskPlacementList = FinalizedShardPlacementList(shardId);

2
src/backend/distributed/commands/table.c
View File

@ -1292,7 +1292,7 @@ InterShardDDLTaskList(Oid leftRelationId, Oid rightRelationId,
task->taskId = taskId++; task->taskId = taskId++;
task->taskType = DDL_TASK; task->taskType = DDL_TASK;
task->queryString = applyCommand->data; task->queryString = applyCommand->data;
task->dependedTaskList = NULL; task->dependentTaskList = NULL;
task->replicationModel = REPLICATION_MODEL_INVALID; task->replicationModel = REPLICATION_MODEL_INVALID;
task->anchorShardId = leftShardId; task->anchorShardId = leftShardId;
task->taskPlacementList = FinalizedShardPlacementList(leftShardId); task->taskPlacementList = FinalizedShardPlacementList(leftShardId);

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

@ -1227,7 +1227,7 @@ DDLTaskList(Oid relationId, const char *commandString)
task->taskType = DDL_TASK; task->taskType = DDL_TASK;
task->queryString = applyCommand->data; task->queryString = applyCommand->data;
task->replicationModel = REPLICATION_MODEL_INVALID; task->replicationModel = REPLICATION_MODEL_INVALID;
task->dependedTaskList = NULL; task->dependentTaskList = NULL;
task->anchorShardId = shardId; task->anchorShardId = shardId;
task->taskPlacementList = FinalizedShardPlacementList(shardId); task->taskPlacementList = FinalizedShardPlacementList(shardId);

2
src/backend/distributed/commands/vacuum.c
View File

@ -226,7 +226,7 @@ VacuumTaskList(Oid relationId, CitusVacuumParams vacuumParams, List *vacuumColum
task->taskId = taskId++; task->taskId = taskId++;
task->taskType = VACUUM_ANALYZE_TASK; task->taskType = VACUUM_ANALYZE_TASK;
task->queryString = pstrdup(vacuumString->data); task->queryString = pstrdup(vacuumString->data);
task->dependedTaskList = NULL; task->dependentTaskList = NULL;
task->replicationModel = REPLICATION_MODEL_INVALID; task->replicationModel = REPLICATION_MODEL_INVALID;
task->anchorShardId = shardId; task->anchorShardId = shardId;
task->taskPlacementList = FinalizedShardPlacementList(shardId); task->taskPlacementList = FinalizedShardPlacementList(shardId);

4
src/backend/distributed/executor/multi_server_executor.c
View File

@ -94,8 +94,8 @@ JobExecutorType(DistributedPlan *distributedPlan)
/* if we have repartition jobs with adaptive executor and repartition /* if we have repartition jobs with adaptive executor and repartition
* joins are not enabled, error out. Otherwise, switch to task-tracker * joins are not enabled, error out. Otherwise, switch to task-tracker
*/ */
int dependedJobCount = list_length(job->dependedJobList); int dependentJobCount = list_length(job->dependentJobList);
if (dependedJobCount > 0) if (dependentJobCount > 0)
{ {
if (!EnableRepartitionJoins) if (!EnableRepartitionJoins)
{ {

60
src/backend/distributed/executor/multi_task_tracker_executor.c
View File

@ -273,7 +273,7 @@ MultiTaskTrackerExecute(Job *job)
else if (taskExecutionStatus == EXEC_SOURCE_TASK_TRACKER_FAILED) else if (taskExecutionStatus == EXEC_SOURCE_TASK_TRACKER_FAILED)
{ {
/* first resolve the map task this map fetch task depends on */ /* first resolve the map task this map fetch task depends on */
Task *mapTask = (Task *) linitial(task->dependedTaskList); Task *mapTask = (Task *) linitial(task->dependentTaskList);
Assert(task->taskType == MAP_OUTPUT_FETCH_TASK); Assert(task->taskType == MAP_OUTPUT_FETCH_TASK);
List *mapFetchTaskList = UpstreamDependencyList(taskAndExecutionList, List *mapFetchTaskList = UpstreamDependencyList(taskAndExecutionList,
@ -469,7 +469,7 @@ TaskAndExecutionList(List *jobTaskList)
List *taskQueue = list_copy(jobTaskList); List *taskQueue = list_copy(jobTaskList);
while (taskQueue != NIL) while (taskQueue != NIL)
{ {
ListCell *dependedTaskCell = NULL; ListCell *dependentTaskCell = NULL;
/* pop first element from the task queue */ /* pop first element from the task queue */
Task *task = (Task *) linitial(taskQueue); Task *task = (Task *) linitial(taskQueue);
@ -481,7 +481,7 @@ TaskAndExecutionList(List *jobTaskList)
taskAndExecutionList = lappend(taskAndExecutionList, task); taskAndExecutionList = lappend(taskAndExecutionList, task);
List *dependendTaskList = task->dependedTaskList; List *dependendTaskList = task->dependentTaskList;
/* /*
* Push task node's children into the task queue, if and only if * Push task node's children into the task queue, if and only if
@ -499,9 +499,9 @@ TaskAndExecutionList(List *jobTaskList)
* taskHash is used to reduce the complexity of keeping track of * taskHash is used to reduce the complexity of keeping track of
* the tasks that are already encountered. * the tasks that are already encountered.
*/ */
foreach(dependedTaskCell, dependendTaskList) foreach(dependentTaskCell, dependendTaskList)
{ {
Task *dependendTask = lfirst(dependedTaskCell); Task *dependendTask = lfirst(dependentTaskCell);
Task *dependendTaskInHash = TaskHashLookup(taskHash, Task *dependendTaskInHash = TaskHashLookup(taskHash,
dependendTask->taskType, dependendTask->taskType,
dependendTask->jobId, dependendTask->jobId,
@ -519,8 +519,8 @@ TaskAndExecutionList(List *jobTaskList)
taskQueue = lappend(taskQueue, dependendTaskInHash); taskQueue = lappend(taskQueue, dependendTaskInHash);
} }
/* update dependedTaskList element to the one which is in the hash */ /* update dependentTaskList element to the one which is in the hash */
lfirst(dependedTaskCell) = dependendTaskInHash; lfirst(dependentTaskCell) = dependendTaskInHash;
} }
} }
@ -966,8 +966,8 @@ ResolveMapTaskTracker(HTAB *trackerHash, Task *task, TaskExecution *taskExecutio
return NULL; return NULL;
} }
Assert(task->dependedTaskList != NIL); Assert(task->dependentTaskList != NIL);
Task *mapTask = (Task *) linitial(task->dependedTaskList); Task *mapTask = (Task *) linitial(task->dependentTaskList);
TaskExecution *mapTaskExecution = mapTask->taskExecution; TaskExecution *mapTaskExecution = mapTask->taskExecution;
TaskTracker *mapTaskTracker = ResolveTaskTracker(trackerHash, mapTask, TaskTracker *mapTaskTracker = ResolveTaskTracker(trackerHash, mapTask,
@ -1043,7 +1043,7 @@ ManageTaskExecution(TaskTracker *taskTracker, TaskTracker *sourceTaskTracker,
* if these dependencies' executions have completed. * if these dependencies' executions have completed.
*/ */
bool taskExecutionsCompleted = TaskExecutionsCompleted( bool taskExecutionsCompleted = TaskExecutionsCompleted(
task->dependedTaskList); task->dependentTaskList);
if (!taskExecutionsCompleted) if (!taskExecutionsCompleted)
{ {
nextExecutionStatus = EXEC_TASK_UNASSIGNED; nextExecutionStatus = EXEC_TASK_UNASSIGNED;
@ -1054,7 +1054,7 @@ ManageTaskExecution(TaskTracker *taskTracker, TaskTracker *sourceTaskTracker,
TaskType taskType = task->taskType; TaskType taskType = task->taskType;
if (taskType == MAP_OUTPUT_FETCH_TASK) if (taskType == MAP_OUTPUT_FETCH_TASK)
{ {
Task *mapTask = (Task *) linitial(task->dependedTaskList); Task *mapTask = (Task *) linitial(task->dependentTaskList);
TaskExecution *mapTaskExecution = mapTask->taskExecution; TaskExecution *mapTaskExecution = mapTask->taskExecution;
StringInfo mapFetchTaskQueryString = MapFetchTaskQueryString(task, StringInfo mapFetchTaskQueryString = MapFetchTaskQueryString(task,
@ -1162,7 +1162,7 @@ ManageTaskExecution(TaskTracker *taskTracker, TaskTracker *sourceTaskTracker,
case EXEC_SOURCE_TASK_TRACKER_RETRY: case EXEC_SOURCE_TASK_TRACKER_RETRY:
{ {
Task *mapTask = (Task *) linitial(task->dependedTaskList); Task *mapTask = (Task *) linitial(task->dependentTaskList);
TaskExecution *mapTaskExecution = mapTask->taskExecution; TaskExecution *mapTaskExecution = mapTask->taskExecution;
uint32 sourceNodeIndex = mapTaskExecution->currentNodeIndex; uint32 sourceNodeIndex = mapTaskExecution->currentNodeIndex;
@ -1807,10 +1807,11 @@ ConstrainedTaskList(List *taskAndExecutionList, Task *task)
foreach(mergeTaskCell, mergeTaskList) foreach(mergeTaskCell, mergeTaskList)
{ {
Task *mergeTask = (Task *) lfirst(mergeTaskCell); Task *mergeTask = (Task *) lfirst(mergeTaskCell);
List *dependedTaskList = mergeTask->dependedTaskList; List *dependentTaskList = mergeTask->dependentTaskList;
constrainedTaskList = lappend(constrainedTaskList, mergeTask); constrainedTaskList = lappend(constrainedTaskList, mergeTask);
constrainedTaskList = TaskListConcatUnique(constrainedTaskList, dependedTaskList); constrainedTaskList = TaskListConcatUnique(constrainedTaskList,
dependentTaskList);
} }
/* /*
@ -1829,14 +1830,15 @@ ConstrainedTaskList(List *taskAndExecutionList, Task *task)
foreach(upstreamTaskCell, upstreamTaskList) foreach(upstreamTaskCell, upstreamTaskList)
{ {
Task *upstreamTask = (Task *) lfirst(upstreamTaskCell); Task *upstreamTask = (Task *) lfirst(upstreamTaskCell);
List *dependedTaskList = upstreamTask->dependedTaskList; List *dependentTaskList = upstreamTask->dependentTaskList;
/* /*
* We already added merge tasks to our constrained list. We therefore use * We already added merge tasks to our constrained list. We therefore use
* concat unique to ensure they don't get appended for a second time. * concat unique to ensure they don't get appended for a second time.
*/ */
constrainedTaskList = TaskListAppendUnique(constrainedTaskList, upstreamTask); constrainedTaskList = TaskListAppendUnique(constrainedTaskList, upstreamTask);
constrainedTaskList = TaskListConcatUnique(constrainedTaskList, dependedTaskList); constrainedTaskList = TaskListConcatUnique(constrainedTaskList,
dependentTaskList);
} }
return constrainedTaskList; return constrainedTaskList;
@ -1852,18 +1854,18 @@ static List *
ConstrainedNonMergeTaskList(List *taskAndExecutionList, Task *task) ConstrainedNonMergeTaskList(List *taskAndExecutionList, Task *task)
{ {
Task *upstreamTask = NULL; Task *upstreamTask = NULL;
List *dependedTaskList = NIL; List *dependentTaskList = NIL;
TaskType taskType = task->taskType; TaskType taskType = task->taskType;
if (taskType == SQL_TASK || taskType == MAP_TASK) if (taskType == SQL_TASK || taskType == MAP_TASK)
{ {
upstreamTask = task; upstreamTask = task;
dependedTaskList = upstreamTask->dependedTaskList; dependentTaskList = upstreamTask->dependentTaskList;
} }
Assert(upstreamTask != NULL); Assert(upstreamTask != NULL);
List *constrainedTaskList = list_make1(upstreamTask); List *constrainedTaskList = list_make1(upstreamTask);
constrainedTaskList = list_concat(constrainedTaskList, dependedTaskList); constrainedTaskList = list_concat(constrainedTaskList, dependentTaskList);
return constrainedTaskList; return constrainedTaskList;
} }
@ -1884,8 +1886,8 @@ UpstreamDependencyList(List *taskAndExecutionList, Task *searchedTask)
foreach(taskAndExecutionCell, taskAndExecutionList) foreach(taskAndExecutionCell, taskAndExecutionList)
{ {
Task *upstreamTask = (Task *) lfirst(taskAndExecutionCell); Task *upstreamTask = (Task *) lfirst(taskAndExecutionCell);
List *dependedTaskList = upstreamTask->dependedTaskList; List *dependentTaskList = upstreamTask->dependentTaskList;
ListCell *dependedTaskCell = NULL; ListCell *dependentTaskCell = NULL;
/* /*
* The given task and its upstream dependency cannot be of the same type. * The given task and its upstream dependency cannot be of the same type.
@ -1901,10 +1903,10 @@ UpstreamDependencyList(List *taskAndExecutionList, Task *searchedTask)
* We walk over the upstream task's dependency list, and check if any of * We walk over the upstream task's dependency list, and check if any of
* them is the task we are looking for. * them is the task we are looking for.
*/ */
foreach(dependedTaskCell, dependedTaskList) foreach(dependentTaskCell, dependentTaskList)
{ {
Task *dependedTask = (Task *) lfirst(dependedTaskCell); Task *dependentTask = (Task *) lfirst(dependentTaskCell);
if (TasksEqual(dependedTask, searchedTask)) if (TasksEqual(dependentTask, searchedTask))
{ {
upstreamTaskList = lappend(upstreamTaskList, upstreamTask); upstreamTaskList = lappend(upstreamTaskList, upstreamTask);
} }
@ -1935,7 +1937,7 @@ ConstrainedMergeTaskList(List *taskAndExecutionList, Task *task)
*/ */
if (taskType == SQL_TASK || taskType == MAP_TASK) if (taskType == SQL_TASK || taskType == MAP_TASK)
{ {
constrainedMergeTaskList = MergeTaskList(task->dependedTaskList); constrainedMergeTaskList = MergeTaskList(task->dependentTaskList);
} }
else if (taskType == MAP_OUTPUT_FETCH_TASK) else if (taskType == MAP_OUTPUT_FETCH_TASK)
{ {
@ -1949,7 +1951,7 @@ ConstrainedMergeTaskList(List *taskAndExecutionList, Task *task)
List *upstreamTaskList = UpstreamDependencyList(taskAndExecutionList, mergeTask); List *upstreamTaskList = UpstreamDependencyList(taskAndExecutionList, mergeTask);
Task *upstreamTask = (Task *) linitial(upstreamTaskList); Task *upstreamTask = (Task *) linitial(upstreamTaskList);
constrainedMergeTaskList = MergeTaskList(upstreamTask->dependedTaskList); constrainedMergeTaskList = MergeTaskList(upstreamTask->dependentTaskList);
} }
else if (taskType == MERGE_TASK) else if (taskType == MERGE_TASK)
{ {
@ -1963,7 +1965,7 @@ ConstrainedMergeTaskList(List *taskAndExecutionList, Task *task)
Assert(upstreamTaskList != NIL); Assert(upstreamTaskList != NIL);
Task *upstreamTask = (Task *) linitial(upstreamTaskList); Task *upstreamTask = (Task *) linitial(upstreamTaskList);
constrainedMergeTaskList = MergeTaskList(upstreamTask->dependedTaskList); constrainedMergeTaskList = MergeTaskList(upstreamTask->dependentTaskList);
} }
return constrainedMergeTaskList; return constrainedMergeTaskList;
@ -2593,8 +2595,8 @@ JobIdList(Job *job)
(*jobIdPointer) = currJob->jobId; (*jobIdPointer) = currJob->jobId;
jobIdList = lappend(jobIdList, jobIdPointer); jobIdList = lappend(jobIdList, jobIdPointer);
/* prevent dependedJobList being modified on list_concat() call */ /* prevent dependentJobList being modified on list_concat() call */
List *jobChildrenList = list_copy(currJob->dependedJobList); List *jobChildrenList = list_copy(currJob->dependentJobList);
if (jobChildrenList != NIL) if (jobChildrenList != NIL)
{ {
jobQueue = list_concat(jobQueue, jobChildrenList); jobQueue = list_concat(jobQueue, jobChildrenList);

2
src/backend/distributed/master/master_stage_protocol.c
View File

@ -516,7 +516,7 @@ CreateShardsOnWorkers(Oid distributedRelationId, List *shardPlacements,
task->taskType = DDL_TASK; task->taskType = DDL_TASK;
task->queryString = StringJoin(commandList, ';'); task->queryString = StringJoin(commandList, ';');
task->replicationModel = REPLICATION_MODEL_INVALID; task->replicationModel = REPLICATION_MODEL_INVALID;
task->dependedTaskList = NIL; task->dependentTaskList = NIL;
task->anchorShardId = shardId; task->anchorShardId = shardId;
task->relationShardList = relationShardList; task->relationShardList = relationShardList;
task->taskPlacementList = list_make1(shardPlacement); task->taskPlacementList = list_make1(shardPlacement);

2
src/backend/distributed/master/master_truncate.c
View File

@ -117,7 +117,7 @@ TruncateTaskList(Oid relationId)
task->taskId = taskId++; task->taskId = taskId++;
task->taskType = DDL_TASK; task->taskType = DDL_TASK;
task->queryString = shardQueryString->data; task->queryString = shardQueryString->data;
task->dependedTaskList = NULL; task->dependentTaskList = NULL;
task->replicationModel = REPLICATION_MODEL_INVALID; task->replicationModel = REPLICATION_MODEL_INVALID;
task->anchorShardId = shardId; task->anchorShardId = shardId;
task->taskPlacementList = FinalizedShardPlacementList(shardId); task->taskPlacementList = FinalizedShardPlacementList(shardId);

8
src/backend/distributed/planner/insert_select_planner.c
View File

@ -283,7 +283,7 @@ CreateDistributedInsertSelectPlan(Query *originalQuery,
Job *workerJob = CitusMakeNode(Job); Job *workerJob = CitusMakeNode(Job);
workerJob->taskList = sqlTaskList; workerJob->taskList = sqlTaskList;
workerJob->subqueryPushdown = false; workerJob->subqueryPushdown = false;
workerJob->dependedJobList = NIL; workerJob->dependentJobList = NIL;
workerJob->jobId = jobId; workerJob->jobId = jobId;
workerJob->jobQuery = originalQuery; workerJob->jobQuery = originalQuery;
workerJob->requiresMasterEvaluation = RequiresMasterEvaluation(originalQuery); workerJob->requiresMasterEvaluation = RequiresMasterEvaluation(originalQuery);
@ -575,7 +575,7 @@ RouterModifyTaskForShardInterval(Query *originalQuery, ShardInterval *shardInter
Task *modifyTask = CreateBasicTask(jobId, taskIdIndex, MODIFY_TASK, Task *modifyTask = CreateBasicTask(jobId, taskIdIndex, MODIFY_TASK,
queryString->data); queryString->data);
modifyTask->dependedTaskList = NULL; modifyTask->dependentTaskList = NULL;
modifyTask->anchorShardId = shardId; modifyTask->anchorShardId = shardId;
modifyTask->taskPlacementList = insertShardPlacementList; modifyTask->taskPlacementList = insertShardPlacementList;
modifyTask->relationShardList = relationShardList; modifyTask->relationShardList = relationShardList;
@ -1178,7 +1178,7 @@ CreateCoordinatorInsertSelectPlan(uint64 planId, Query *parse)
Job *workerJob = CitusMakeNode(Job); Job *workerJob = CitusMakeNode(Job);
workerJob->taskList = taskList; workerJob->taskList = taskList;
workerJob->subqueryPushdown = false; workerJob->subqueryPushdown = false;
workerJob->dependedJobList = NIL; workerJob->dependentJobList = NIL;
workerJob->jobId = jobId; workerJob->jobId = jobId;
workerJob->jobQuery = insertSelectQuery; workerJob->jobQuery = insertSelectQuery;
workerJob->requiresMasterEvaluation = false; workerJob->requiresMasterEvaluation = false;
@ -1397,7 +1397,7 @@ TwoPhaseInsertSelectTaskList(Oid targetRelationId, Query *insertSelectQuery,
Task *modifyTask = CreateBasicTask(jobId, taskIdIndex, MODIFY_TASK, Task *modifyTask = CreateBasicTask(jobId, taskIdIndex, MODIFY_TASK,
queryString->data); queryString->data);
modifyTask->dependedTaskList = NULL; modifyTask->dependentTaskList = NULL;
modifyTask->anchorShardId = shardId; modifyTask->anchorShardId = shardId;
modifyTask->taskPlacementList = insertShardPlacementList; modifyTask->taskPlacementList = insertShardPlacementList;
modifyTask->relationShardList = list_make1(relationShard); modifyTask->relationShardList = list_make1(relationShard);

34
src/backend/distributed/planner/multi_explain.c
View File

@ -213,9 +213,9 @@ ExplainSubPlans(DistributedPlan *distributedPlan, ExplainState *es)
static void static void
ExplainJob(Job *job, ExplainState *es) ExplainJob(Job *job, ExplainState *es)
{ {
List *dependedJobList = job->dependedJobList; List *dependentJobList = job->dependentJobList;
int dependedJobCount = list_length(dependedJobList); int dependentJobCount = list_length(dependentJobList);
ListCell *dependedJobCell = NULL; ListCell *dependentJobCell = NULL;
List *taskList = job->taskList; List *taskList = job->taskList;
int taskCount = list_length(taskList); int taskCount = list_length(taskList);
@ -223,7 +223,7 @@ ExplainJob(Job *job, ExplainState *es)
ExplainPropertyInteger("Task Count", NULL, taskCount, es); ExplainPropertyInteger("Task Count", NULL, taskCount, es);
if (dependedJobCount > 0) if (dependentJobCount > 0)
{ {
ExplainPropertyText("Tasks Shown", "None, not supported for re-partition " ExplainPropertyText("Tasks Shown", "None, not supported for re-partition "
"queries", es); "queries", es);
@ -244,7 +244,7 @@ ExplainJob(Job *job, ExplainState *es)
* We cannot fetch EXPLAIN plans for jobs that have dependencies, since the * We cannot fetch EXPLAIN plans for jobs that have dependencies, since the
* intermediate tables have not been created. * intermediate tables have not been created.
*/ */
if (dependedJobCount == 0) if (dependentJobCount == 0)
{ {
ExplainOpenGroup("Tasks", "Tasks", false, es); ExplainOpenGroup("Tasks", "Tasks", false, es);
@ -257,13 +257,13 @@ ExplainJob(Job *job, ExplainState *es)
ExplainOpenGroup("Depended Jobs", "Depended Jobs", false, es); ExplainOpenGroup("Depended Jobs", "Depended Jobs", false, es);
/* show explain output for depended jobs, if any */ /* show explain output for depended jobs, if any */
foreach(dependedJobCell, dependedJobList) foreach(dependentJobCell, dependentJobList)
{ {
Job *dependedJob = (Job *) lfirst(dependedJobCell); Job *dependentJob = (Job *) lfirst(dependentJobCell);
if (CitusIsA(dependedJob, MapMergeJob)) if (CitusIsA(dependentJob, MapMergeJob))
{ {
ExplainMapMergeJob((MapMergeJob *) dependedJob, es); ExplainMapMergeJob((MapMergeJob *) dependentJob, es);
} }
} }
@ -283,9 +283,9 @@ ExplainJob(Job *job, ExplainState *es)
static void static void
ExplainMapMergeJob(MapMergeJob *mapMergeJob, ExplainState *es) ExplainMapMergeJob(MapMergeJob *mapMergeJob, ExplainState *es)
{ {
List *dependedJobList = mapMergeJob->job.dependedJobList; List *dependentJobList = mapMergeJob->job.dependentJobList;
int dependedJobCount = list_length(dependedJobList); int dependentJobCount = list_length(dependentJobList);
ListCell *dependedJobCell = NULL; ListCell *dependentJobCell = NULL;
int mapTaskCount = list_length(mapMergeJob->mapTaskList); int mapTaskCount = list_length(mapMergeJob->mapTaskList);
int mergeTaskCount = list_length(mapMergeJob->mergeTaskList); int mergeTaskCount = list_length(mapMergeJob->mergeTaskList);
@ -300,17 +300,17 @@ ExplainMapMergeJob(MapMergeJob *mapMergeJob, ExplainState *es)
ExplainPropertyInteger("Map Task Count", NULL, mapTaskCount, es); ExplainPropertyInteger("Map Task Count", NULL, mapTaskCount, es);
ExplainPropertyInteger("Merge Task Count", NULL, mergeTaskCount, es); ExplainPropertyInteger("Merge Task Count", NULL, mergeTaskCount, es);
if (dependedJobCount > 0) if (dependentJobCount > 0)
{ {
ExplainOpenGroup("Depended Jobs", "Depended Jobs", false, es); ExplainOpenGroup("Depended Jobs", "Depended Jobs", false, es);
foreach(dependedJobCell, dependedJobList) foreach(dependentJobCell, dependentJobList)
{ {
Job *dependedJob = (Job *) lfirst(dependedJobCell); Job *dependentJob = (Job *) lfirst(dependentJobCell);
if (CitusIsA(dependedJob, MapMergeJob)) if (CitusIsA(dependentJob, MapMergeJob))
{ {
ExplainMapMergeJob((MapMergeJob *) dependedJob, es); ExplainMapMergeJob((MapMergeJob *) dependentJob, es);
} }
} }

256
src/backend/distributed/planner/multi_physical_planner.c
View File

@ -94,8 +94,8 @@ static Job * BuildJobTree(MultiTreeRoot *multiTree);
static MultiNode * LeftMostNode(MultiTreeRoot *multiTree); static MultiNode * LeftMostNode(MultiTreeRoot *multiTree);
static Oid RangePartitionJoinBaseRelationId(MultiJoin *joinNode); static Oid RangePartitionJoinBaseRelationId(MultiJoin *joinNode);
static MultiTable * FindTableNode(MultiNode *multiNode, int rangeTableId); static MultiTable * FindTableNode(MultiNode *multiNode, int rangeTableId);
static Query * BuildJobQuery(MultiNode *multiNode, List *dependedJobList); static Query * BuildJobQuery(MultiNode *multiNode, List *dependentJobList);
static Query * BuildReduceQuery(MultiExtendedOp *extendedOpNode, List *dependedJobList); static Query * BuildReduceQuery(MultiExtendedOp *extendedOpNode, List *dependentJobList);
static List * BaseRangeTableList(MultiNode *multiNode); static List * BaseRangeTableList(MultiNode *multiNode);
static List * QueryTargetList(MultiNode *multiNode); static List * QueryTargetList(MultiNode *multiNode);
static List * TargetEntryList(List *expressionList); static List * TargetEntryList(List *expressionList);
@ -103,29 +103,29 @@ static List * QueryGroupClauseList(MultiNode *multiNode);
static List * QuerySelectClauseList(MultiNode *multiNode); static List * QuerySelectClauseList(MultiNode *multiNode);
static List * QueryJoinClauseList(MultiNode *multiNode); static List * QueryJoinClauseList(MultiNode *multiNode);
static List * QueryFromList(List *rangeTableList); static List * QueryFromList(List *rangeTableList);
static Node * QueryJoinTree(MultiNode *multiNode, List *dependedJobList, static Node * QueryJoinTree(MultiNode *multiNode, List *dependentJobList,
List **rangeTableList); List **rangeTableList);
static RangeTblEntry * JoinRangeTableEntry(JoinExpr *joinExpr, List *dependedJobList, static RangeTblEntry * JoinRangeTableEntry(JoinExpr *joinExpr, List *dependentJobList,
List *rangeTableList); List *rangeTableList);
static int ExtractRangeTableId(Node *node); static int ExtractRangeTableId(Node *node);
static void ExtractColumns(RangeTblEntry *rangeTableEntry, int rangeTableId, static void ExtractColumns(RangeTblEntry *rangeTableEntry, int rangeTableId,
List *dependedJobList, List **columnNames, List **columnVars); List *dependentJobList, List **columnNames, List **columnVars);
static RangeTblEntry * DerivedRangeTableEntry(MultiNode *multiNode, List *columnNames, static RangeTblEntry * DerivedRangeTableEntry(MultiNode *multiNode, List *columnNames,
List *tableIdList); List *tableIdList);
static List * DerivedColumnNameList(uint32 columnCount, uint64 generatingJobId); static List * DerivedColumnNameList(uint32 columnCount, uint64 generatingJobId);
static Query * BuildSubqueryJobQuery(MultiNode *multiNode); static Query * BuildSubqueryJobQuery(MultiNode *multiNode);
static void UpdateAllColumnAttributes(Node *columnContainer, List *rangeTableList, static void UpdateAllColumnAttributes(Node *columnContainer, List *rangeTableList,
List *dependedJobList); List *dependentJobList);
static void UpdateColumnAttributes(Var *column, List *rangeTableList, static void UpdateColumnAttributes(Var *column, List *rangeTableList,
List *dependedJobList); List *dependentJobList);
static Index NewTableId(Index originalTableId, List *rangeTableList); static Index NewTableId(Index originalTableId, List *rangeTableList);
static AttrNumber NewColumnId(Index originalTableId, AttrNumber originalColumnId, static AttrNumber NewColumnId(Index originalTableId, AttrNumber originalColumnId,
RangeTblEntry *newRangeTableEntry, List *dependedJobList); RangeTblEntry *newRangeTableEntry, List *dependentJobList);
static Job * JobForRangeTable(List *jobList, RangeTblEntry *rangeTableEntry); static Job * JobForRangeTable(List *jobList, RangeTblEntry *rangeTableEntry);
static Job * JobForTableIdList(List *jobList, List *searchedTableIdList); static Job * JobForTableIdList(List *jobList, List *searchedTableIdList);
static List * ChildNodeList(MultiNode *multiNode); static List * ChildNodeList(MultiNode *multiNode);
static Job * BuildJob(Query *jobQuery, List *dependedJobList); static Job * BuildJob(Query *jobQuery, List *dependentJobList);
static MapMergeJob * BuildMapMergeJob(Query *jobQuery, List *dependedJobList, static MapMergeJob * BuildMapMergeJob(Query *jobQuery, List *dependentJobList,
Var *partitionKey, PartitionType partitionType, Var *partitionKey, PartitionType partitionType,
Oid baseRelationId, Oid baseRelationId,
BoundaryNodeJobType boundaryNodeJobType); BoundaryNodeJobType boundaryNodeJobType);
@ -153,15 +153,16 @@ static List * BaseRangeTableIdList(List *rangeTableList);
static List * AnchorRangeTableIdList(List *rangeTableList, List *baseRangeTableIdList); static List * AnchorRangeTableIdList(List *rangeTableList, List *baseRangeTableIdList);
static void AdjustColumnOldAttributes(List *expressionList); static void AdjustColumnOldAttributes(List *expressionList);
static List * RangeTableFragmentsList(List *rangeTableList, List *whereClauseList, static List * RangeTableFragmentsList(List *rangeTableList, List *whereClauseList,
List *dependedJobList); List *dependentJobList);
static OperatorCacheEntry * LookupOperatorByType(Oid typeId, Oid accessMethodId, static OperatorCacheEntry * LookupOperatorByType(Oid typeId, Oid accessMethodId,
int16 strategyNumber); int16 strategyNumber);
static Oid GetOperatorByType(Oid typeId, Oid accessMethodId, int16 strategyNumber); static Oid GetOperatorByType(Oid typeId, Oid accessMethodId, int16 strategyNumber);
static List * FragmentCombinationList(List *rangeTableFragmentsList, Query *jobQuery, static List * FragmentCombinationList(List *rangeTableFragmentsList, Query *jobQuery,
List *dependedJobList); List *dependentJobList);
static JoinSequenceNode * JoinSequenceArray(List *rangeTableFragmentsList, static JoinSequenceNode * JoinSequenceArray(List *rangeTableFragmentsList,
Query *jobQuery, List *dependedJobList); Query *jobQuery, List *dependentJobList);
static bool PartitionedOnColumn(Var *column, List *rangeTableList, List *dependedJobList); static bool PartitionedOnColumn(Var *column, List *rangeTableList,
List *dependentJobList);
static void CheckJoinBetweenColumns(OpExpr *joinClause); static void CheckJoinBetweenColumns(OpExpr *joinClause);
static List * FindRangeTableFragmentsList(List *rangeTableFragmentsList, int taskId); static List * FindRangeTableFragmentsList(List *rangeTableFragmentsList, int taskId);
static bool JoinPrunable(RangeTableFragment *leftFragment, static bool JoinPrunable(RangeTableFragment *leftFragment,
@ -224,8 +225,8 @@ CreatePhysicalDistributedPlan(MultiTreeRoot *multiTree,
workerJob = BuildJobTreeTaskList(workerJob, plannerRestrictionContext); workerJob = BuildJobTreeTaskList(workerJob, plannerRestrictionContext);
/* build the final merge query to execute on the master */ /* build the final merge query to execute on the master */
List *masterDependedJobList = list_make1(workerJob); List *masterDependentJobList = list_make1(workerJob);
Query *masterQuery = BuildJobQuery((MultiNode *) multiTree, masterDependedJobList); Query *masterQuery = BuildJobQuery((MultiNode *) multiTree, masterDependentJobList);
DistributedPlan *distributedPlan = CitusMakeNode(DistributedPlan); DistributedPlan *distributedPlan = CitusMakeNode(DistributedPlan);
distributedPlan->workerJob = workerJob; distributedPlan->workerJob = workerJob;
@ -252,7 +253,7 @@ DistributedPlanRouterExecutable(DistributedPlan *distributedPlan)
Job *job = distributedPlan->workerJob; Job *job = distributedPlan->workerJob;
List *workerTaskList = job->taskList; List *workerTaskList = job->taskList;
int taskCount = list_length(workerTaskList); int taskCount = list_length(workerTaskList);
int dependedJobCount = list_length(job->dependedJobList); int dependentJobCount = list_length(job->dependentJobList);
if (!EnableRouterExecution) if (!EnableRouterExecution)
{ {
@ -266,7 +267,7 @@ DistributedPlanRouterExecutable(DistributedPlan *distributedPlan)
} }
/* router executor cannot execute repartition jobs */ /* router executor cannot execute repartition jobs */
if (dependedJobCount > 0) if (dependentJobCount > 0)
{ {
return false; return false;
} }
@ -309,7 +310,7 @@ BuildJobTree(MultiTreeRoot *multiTree)
MultiNode *leftMostNode = LeftMostNode(multiTree); MultiNode *leftMostNode = LeftMostNode(multiTree);
MultiNode *currentNode = leftMostNode; MultiNode *currentNode = leftMostNode;
MultiNode *parentNode = ParentNode(currentNode); MultiNode *parentNode = ParentNode(currentNode);
List *loopDependedJobList = NIL; List *loopDependentJobList = NIL;
Job *topLevelJob = NULL; Job *topLevelJob = NULL;
while (parentNode != NULL) while (parentNode != NULL)
@ -375,17 +376,17 @@ BuildJobTree(MultiTreeRoot *multiTree)
Var *partitionKey = partitionNode->partitionColumn; Var *partitionKey = partitionNode->partitionColumn;
/* build query and partition job */ /* build query and partition job */
List *dependedJobList = list_copy(loopDependedJobList); List *dependentJobList = list_copy(loopDependentJobList);
Query *jobQuery = BuildJobQuery(queryNode, dependedJobList); Query *jobQuery = BuildJobQuery(queryNode, dependentJobList);
MapMergeJob *mapMergeJob = BuildMapMergeJob(jobQuery, dependedJobList, MapMergeJob *mapMergeJob = BuildMapMergeJob(jobQuery, dependentJobList,
partitionKey, partitionType, partitionKey, partitionType,
baseRelationId, baseRelationId,
JOIN_MAP_MERGE_JOB); JOIN_MAP_MERGE_JOB);
/* reset depended job list */ /* reset depended job list */
loopDependedJobList = NIL; loopDependentJobList = NIL;
loopDependedJobList = list_make1(mapMergeJob); loopDependentJobList = list_make1(mapMergeJob);
} }
if (CitusIsA(rightChildNode, MultiPartition)) if (CitusIsA(rightChildNode, MultiPartition))
@ -405,7 +406,7 @@ BuildJobTree(MultiTreeRoot *multiTree)
JOIN_MAP_MERGE_JOB); JOIN_MAP_MERGE_JOB);
/* append to the depended job list for on-going dependencies */ /* append to the depended job list for on-going dependencies */
loopDependedJobList = lappend(loopDependedJobList, mapMergeJob); loopDependentJobList = lappend(loopDependentJobList, mapMergeJob);
} }
} }
else if (boundaryNodeJobType == SUBQUERY_MAP_MERGE_JOB) else if (boundaryNodeJobType == SUBQUERY_MAP_MERGE_JOB)
@ -415,10 +416,10 @@ BuildJobTree(MultiTreeRoot *multiTree)
Var *partitionKey = partitionNode->partitionColumn; Var *partitionKey = partitionNode->partitionColumn;
/* build query and partition job */ /* build query and partition job */
List *dependedJobList = list_copy(loopDependedJobList); List *dependentJobList = list_copy(loopDependentJobList);
Query *jobQuery = BuildJobQuery(queryNode, dependedJobList); Query *jobQuery = BuildJobQuery(queryNode, dependentJobList);
MapMergeJob *mapMergeJob = BuildMapMergeJob(jobQuery, dependedJobList, MapMergeJob *mapMergeJob = BuildMapMergeJob(jobQuery, dependentJobList,
partitionKey, partitionKey,
DUAL_HASH_PARTITION_TYPE, DUAL_HASH_PARTITION_TYPE,
InvalidOid, InvalidOid,
@ -429,13 +430,13 @@ BuildJobTree(MultiTreeRoot *multiTree)
mapMergeJob->reduceQuery = reduceQuery; mapMergeJob->reduceQuery = reduceQuery;
/* reset depended job list */ /* reset depended job list */
loopDependedJobList = NIL; loopDependentJobList = NIL;
loopDependedJobList = list_make1(mapMergeJob); loopDependentJobList = list_make1(mapMergeJob);
} }
else if (boundaryNodeJobType == TOP_LEVEL_WORKER_JOB) else if (boundaryNodeJobType == TOP_LEVEL_WORKER_JOB)
{ {
MultiNode *childNode = ChildNode((MultiUnaryNode *) currentNode); MultiNode *childNode = ChildNode((MultiUnaryNode *) currentNode);
List *dependedJobList = list_copy(loopDependedJobList); List *dependentJobList = list_copy(loopDependentJobList);
bool subqueryPushdown = false; bool subqueryPushdown = false;
List *subqueryMultiTableList = SubqueryMultiTableList(childNode); List *subqueryMultiTableList = SubqueryMultiTableList(childNode);
@ -456,14 +457,14 @@ BuildJobTree(MultiTreeRoot *multiTree)
{ {
Query *topLevelQuery = BuildSubqueryJobQuery(childNode); Query *topLevelQuery = BuildSubqueryJobQuery(childNode);
topLevelJob = BuildJob(topLevelQuery, dependedJobList); topLevelJob = BuildJob(topLevelQuery, dependentJobList);
topLevelJob->subqueryPushdown = true; topLevelJob->subqueryPushdown = true;
} }
else else
{ {
Query *topLevelQuery = BuildJobQuery(childNode, dependedJobList); Query *topLevelQuery = BuildJobQuery(childNode, dependentJobList);
topLevelJob = BuildJob(topLevelQuery, dependedJobList); topLevelJob = BuildJob(topLevelQuery, dependentJobList);
} }
} }
@ -569,7 +570,7 @@ FindTableNode(MultiNode *multiNode, int rangeTableId)
* have already been built, as their output is needed to build the query. * have already been built, as their output is needed to build the query.
*/ */
static Query * static Query *
BuildJobQuery(MultiNode *multiNode, List *dependedJobList) BuildJobQuery(MultiNode *multiNode, List *dependentJobList)
{ {
bool updateColumnAttributes = false; bool updateColumnAttributes = false;
List *targetList = NIL; List *targetList = NIL;
@ -604,9 +605,9 @@ BuildJobQuery(MultiNode *multiNode, List *dependedJobList)
* If we are building this query on a repartitioned subquery job then we * If we are building this query on a repartitioned subquery job then we
* don't need to update column attributes. * don't need to update column attributes.
*/ */
if (dependedJobList != NIL) if (dependentJobList != NIL)
{ {
Job *job = (Job *) linitial(dependedJobList); Job *job = (Job *) linitial(dependentJobList);
if (CitusIsA(job, MapMergeJob)) if (CitusIsA(job, MapMergeJob))
{ {
MapMergeJob *mapMergeJob = (MapMergeJob *) job; MapMergeJob *mapMergeJob = (MapMergeJob *) job;
@ -638,12 +639,12 @@ BuildJobQuery(MultiNode *multiNode, List *dependedJobList)
/* build the join tree and the range table list */ /* build the join tree and the range table list */
List *rangeTableList = BaseRangeTableList(multiNode); List *rangeTableList = BaseRangeTableList(multiNode);
Node *joinRoot = QueryJoinTree(multiNode, dependedJobList, &rangeTableList); Node *joinRoot = QueryJoinTree(multiNode, dependentJobList, &rangeTableList);
/* update the column attributes for target entries */ /* update the column attributes for target entries */
if (updateColumnAttributes) if (updateColumnAttributes)
{ {
UpdateAllColumnAttributes((Node *) targetList, rangeTableList, dependedJobList); UpdateAllColumnAttributes((Node *) targetList, rangeTableList, dependentJobList);
} }
/* extract limit count/offset and sort clauses */ /* extract limit count/offset and sort clauses */
@ -668,8 +669,8 @@ BuildJobQuery(MultiNode *multiNode, List *dependedJobList)
if (updateColumnAttributes) if (updateColumnAttributes)
{ {
UpdateAllColumnAttributes((Node *) selectClauseList, rangeTableList, UpdateAllColumnAttributes((Node *) selectClauseList, rangeTableList,
dependedJobList); dependentJobList);
UpdateAllColumnAttributes(havingQual, rangeTableList, dependedJobList); UpdateAllColumnAttributes(havingQual, rangeTableList, dependentJobList);
} }
/* /*
@ -726,7 +727,7 @@ BuildJobQuery(MultiNode *multiNode, List *dependedJobList)
* have already been built, as their output is needed to build the query. * have already been built, as their output is needed to build the query.
*/ */
static Query * static Query *
BuildReduceQuery(MultiExtendedOp *extendedOpNode, List *dependedJobList) BuildReduceQuery(MultiExtendedOp *extendedOpNode, List *dependentJobList)
{ {
MultiNode *multiNode = (MultiNode *) extendedOpNode; MultiNode *multiNode = (MultiNode *) extendedOpNode;
List *derivedRangeTableList = NIL; List *derivedRangeTableList = NIL;
@ -734,8 +735,8 @@ BuildReduceQuery(MultiExtendedOp *extendedOpNode, List *dependedJobList)
ListCell *columnCell = NULL; ListCell *columnCell = NULL;
List *columnNameList = NIL; List *columnNameList = NIL;
Job *dependedJob = linitial(dependedJobList); Job *dependentJob = linitial(dependentJobList);
List *dependedTargetList = dependedJob->jobQuery->targetList; List *dependedTargetList = dependentJob->jobQuery->targetList;
uint32 columnCount = (uint32) list_length(dependedTargetList); uint32 columnCount = (uint32) list_length(dependedTargetList);
for (uint32 columnIndex = 0; columnIndex < columnCount; columnIndex++) for (uint32 columnIndex = 0; columnIndex < columnCount; columnIndex++)
@ -1121,7 +1122,7 @@ QueryJoinClauseList(MultiNode *multiNode)
* the entries at the same time as the tree to know the appropriate rtindex. * the entries at the same time as the tree to know the appropriate rtindex.
*/ */
static Node * static Node *
QueryJoinTree(MultiNode *multiNode, List *dependedJobList, List **rangeTableList) QueryJoinTree(MultiNode *multiNode, List *dependentJobList, List **rangeTableList)
{ {
CitusNodeTag nodeType = CitusNodeTag(multiNode); CitusNodeTag nodeType = CitusNodeTag(multiNode);
@ -1135,9 +1136,9 @@ QueryJoinTree(MultiNode *multiNode, List *dependedJobList, List **rangeTableList
JoinExpr *joinExpr = makeNode(JoinExpr); JoinExpr *joinExpr = makeNode(JoinExpr);
joinExpr->jointype = joinNode->joinType; joinExpr->jointype = joinNode->joinType;
joinExpr->isNatural = false; joinExpr->isNatural = false;
joinExpr->larg = QueryJoinTree(binaryNode->leftChildNode, dependedJobList, joinExpr->larg = QueryJoinTree(binaryNode->leftChildNode, dependentJobList,
rangeTableList); rangeTableList);
joinExpr->rarg = QueryJoinTree(binaryNode->rightChildNode, dependedJobList, joinExpr->rarg = QueryJoinTree(binaryNode->rightChildNode, dependentJobList,
rangeTableList); rangeTableList);
joinExpr->usingClause = NIL; joinExpr->usingClause = NIL;
joinExpr->alias = NULL; joinExpr->alias = NULL;
@ -1161,7 +1162,7 @@ QueryJoinTree(MultiNode *multiNode, List *dependedJobList, List **rangeTableList
} }
RangeTblEntry *rangeTableEntry = JoinRangeTableEntry(joinExpr, RangeTblEntry *rangeTableEntry = JoinRangeTableEntry(joinExpr,
dependedJobList, dependentJobList,
*rangeTableList); *rangeTableList);
*rangeTableList = lappend(*rangeTableList, rangeTableEntry); *rangeTableList = lappend(*rangeTableList, rangeTableEntry);
@ -1170,7 +1171,7 @@ QueryJoinTree(MultiNode *multiNode, List *dependedJobList, List **rangeTableList
foreach(columnCell, columnList) foreach(columnCell, columnList)
{ {
Var *column = (Var *) lfirst(columnCell); Var *column = (Var *) lfirst(columnCell);
UpdateColumnAttributes(column, *rangeTableList, dependedJobList); UpdateColumnAttributes(column, *rangeTableList, dependentJobList);
/* adjust our column old attributes for partition pruning to work */ /* adjust our column old attributes for partition pruning to work */
column->varnoold = column->varno; column->varnoold = column->varno;
@ -1191,7 +1192,7 @@ QueryJoinTree(MultiNode *multiNode, List *dependedJobList, List **rangeTableList
if (unaryNode->childNode != NULL) if (unaryNode->childNode != NULL)
{ {
/* MultiTable is actually a subquery, return the query tree below */ /* MultiTable is actually a subquery, return the query tree below */
Node *childNode = QueryJoinTree(unaryNode->childNode, dependedJobList, Node *childNode = QueryJoinTree(unaryNode->childNode, dependentJobList,
rangeTableList); rangeTableList);
return childNode; return childNode;
@ -1209,12 +1210,13 @@ QueryJoinTree(MultiNode *multiNode, List *dependedJobList, List **rangeTableList
case T_MultiCollect: case T_MultiCollect:
{ {
List *tableIdList = OutputTableIdList(multiNode); List *tableIdList = OutputTableIdList(multiNode);
Job *dependedJob = JobForTableIdList(dependedJobList, tableIdList); Job *dependentJob = JobForTableIdList(dependentJobList, tableIdList);
List *dependedTargetList = dependedJob->jobQuery->targetList; List *dependedTargetList = dependentJob->jobQuery->targetList;
/* compute column names for the derived table */ /* compute column names for the derived table */
uint32 columnCount = (uint32) list_length(dependedTargetList); uint32 columnCount = (uint32) list_length(dependedTargetList);
List *columnNameList = DerivedColumnNameList(columnCount, dependedJob->jobId); List *columnNameList = DerivedColumnNameList(columnCount,
dependentJob->jobId);
RangeTblEntry *rangeTableEntry = DerivedRangeTableEntry(multiNode, RangeTblEntry *rangeTableEntry = DerivedRangeTableEntry(multiNode,
columnNameList, columnNameList,
@ -1234,9 +1236,9 @@ QueryJoinTree(MultiNode *multiNode, List *dependedJobList, List **rangeTableList
JoinExpr *joinExpr = makeNode(JoinExpr); JoinExpr *joinExpr = makeNode(JoinExpr);
joinExpr->jointype = JOIN_INNER; joinExpr->jointype = JOIN_INNER;
joinExpr->isNatural = false; joinExpr->isNatural = false;
joinExpr->larg = QueryJoinTree(binaryNode->leftChildNode, dependedJobList, joinExpr->larg = QueryJoinTree(binaryNode->leftChildNode, dependentJobList,
rangeTableList); rangeTableList);
joinExpr->rarg = QueryJoinTree(binaryNode->rightChildNode, dependedJobList, joinExpr->rarg = QueryJoinTree(binaryNode->rightChildNode, dependentJobList,
rangeTableList); rangeTableList);
joinExpr->usingClause = NIL; joinExpr->usingClause = NIL;
joinExpr->alias = NULL; joinExpr->alias = NULL;
@ -1244,7 +1246,7 @@ QueryJoinTree(MultiNode *multiNode, List *dependedJobList, List **rangeTableList
joinExpr->rtindex = list_length(*rangeTableList) + 1; joinExpr->rtindex = list_length(*rangeTableList) + 1;
RangeTblEntry *rangeTableEntry = JoinRangeTableEntry(joinExpr, RangeTblEntry *rangeTableEntry = JoinRangeTableEntry(joinExpr,
dependedJobList, dependentJobList,
*rangeTableList); *rangeTableList);
*rangeTableList = lappend(*rangeTableList, rangeTableEntry); *rangeTableList = lappend(*rangeTableList, rangeTableEntry);
@ -1261,7 +1263,7 @@ QueryJoinTree(MultiNode *multiNode, List *dependedJobList, List **rangeTableList
Assert(UnaryOperator(multiNode)); Assert(UnaryOperator(multiNode));
Node *childNode = QueryJoinTree(unaryNode->childNode, dependedJobList, Node *childNode = QueryJoinTree(unaryNode->childNode, dependentJobList,
rangeTableList); rangeTableList);
return childNode; return childNode;
@ -1281,7 +1283,7 @@ QueryJoinTree(MultiNode *multiNode, List *dependedJobList, List **rangeTableList
* transformFromClauseItem. * transformFromClauseItem.
*/ */
static RangeTblEntry * static RangeTblEntry *
JoinRangeTableEntry(JoinExpr *joinExpr, List *dependedJobList, List *rangeTableList) JoinRangeTableEntry(JoinExpr *joinExpr, List *dependentJobList, List *rangeTableList)
{ {
RangeTblEntry *rangeTableEntry = makeNode(RangeTblEntry); RangeTblEntry *rangeTableEntry = makeNode(RangeTblEntry);
List *joinedColumnNames = NIL; List *joinedColumnNames = NIL;
@ -1303,9 +1305,9 @@ JoinRangeTableEntry(JoinExpr *joinExpr, List *dependedJobList, List *rangeTableL
rangeTableEntry->subquery = NULL; rangeTableEntry->subquery = NULL;
rangeTableEntry->eref = makeAlias("unnamed_join", NIL); rangeTableEntry->eref = makeAlias("unnamed_join", NIL);
ExtractColumns(leftRTE, leftRangeTableId, dependedJobList, ExtractColumns(leftRTE, leftRangeTableId, dependentJobList,
&leftColumnNames, &leftColumnVars); &leftColumnNames, &leftColumnVars);
ExtractColumns(rightRTE, rightRangeTableId, dependedJobList, ExtractColumns(rightRTE, rightRangeTableId, dependentJobList,
&rightColumnNames, &rightColumnVars); &rightColumnNames, &rightColumnVars);
joinedColumnNames = list_concat(joinedColumnNames, leftColumnNames); joinedColumnNames = list_concat(joinedColumnNames, leftColumnNames);
@ -1353,7 +1355,7 @@ ExtractRangeTableId(Node *node)
* to a form that expandRTE can handle. * to a form that expandRTE can handle.
*/ */
static void static void
ExtractColumns(RangeTblEntry *rangeTableEntry, int rangeTableId, List *dependedJobList, ExtractColumns(RangeTblEntry *rangeTableEntry, int rangeTableId, List *dependentJobList,
List **columnNames, List **columnVars) List **columnNames, List **columnVars)
{ {
RangeTblEntry *callingRTE = NULL; RangeTblEntry *callingRTE = NULL;
@ -1380,8 +1382,8 @@ ExtractColumns(RangeTblEntry *rangeTableEntry, int rangeTableId, List *dependedJ
} }
else if (rangeTableKind == CITUS_RTE_REMOTE_QUERY) else if (rangeTableKind == CITUS_RTE_REMOTE_QUERY)
{ {
Job *dependedJob = JobForRangeTable(dependedJobList, rangeTableEntry); Job *dependentJob = JobForRangeTable(dependentJobList, rangeTableEntry);
Query *jobQuery = dependedJob->jobQuery; Query *jobQuery = dependentJob->jobQuery;
/* /*
* For re-partition jobs, we construct a subquery RTE to call expandRTE, * For re-partition jobs, we construct a subquery RTE to call expandRTE,
@ -1564,14 +1566,14 @@ BuildSubqueryJobQuery(MultiNode *multiNode)
*/ */
static void static void
UpdateAllColumnAttributes(Node *columnContainer, List *rangeTableList, UpdateAllColumnAttributes(Node *columnContainer, List *rangeTableList,
List *dependedJobList) List *dependentJobList)
{ {
ListCell *columnCell = NULL; ListCell *columnCell = NULL;
List *columnList = pull_var_clause_default(columnContainer); List *columnList = pull_var_clause_default(columnContainer);
foreach(columnCell, columnList) foreach(columnCell, columnList)
{ {
Var *column = (Var *) lfirst(columnCell); Var *column = (Var *) lfirst(columnCell);
UpdateColumnAttributes(column, rangeTableList, dependedJobList); UpdateColumnAttributes(column, rangeTableList, dependentJobList);
} }
} }
@ -1582,7 +1584,7 @@ UpdateAllColumnAttributes(Node *columnContainer, List *rangeTableList,
* newly built range table list to update the given column's attributes. * newly built range table list to update the given column's attributes.
*/ */
static void static void
UpdateColumnAttributes(Var *column, List *rangeTableList, List *dependedJobList) UpdateColumnAttributes(Var *column, List *rangeTableList, List *dependentJobList)
{ {
Index originalTableId = column->varnoold; Index originalTableId = column->varnoold;
AttrNumber originalColumnId = column->varoattno; AttrNumber originalColumnId = column->varoattno;
@ -1596,7 +1598,7 @@ UpdateColumnAttributes(Var *column, List *rangeTableList, List *dependedJobList)
if (GetRangeTblKind(newRangeTableEntry) == CITUS_RTE_REMOTE_QUERY) if (GetRangeTblKind(newRangeTableEntry) == CITUS_RTE_REMOTE_QUERY)
{ {
newColumnId = NewColumnId(originalTableId, originalColumnId, newColumnId = NewColumnId(originalTableId, originalColumnId,
newRangeTableEntry, dependedJobList); newRangeTableEntry, dependentJobList);
} }
column->varno = newTableId; column->varno = newTableId;
@ -1648,13 +1650,13 @@ NewTableId(Index originalTableId, List *rangeTableList)
*/ */
static AttrNumber static AttrNumber
NewColumnId(Index originalTableId, AttrNumber originalColumnId, NewColumnId(Index originalTableId, AttrNumber originalColumnId,
RangeTblEntry *newRangeTableEntry, List *dependedJobList) RangeTblEntry *newRangeTableEntry, List *dependentJobList)
{ {
AttrNumber newColumnId = 1; AttrNumber newColumnId = 1;
AttrNumber columnIndex = 1; AttrNumber columnIndex = 1;
Job *dependedJob = JobForRangeTable(dependedJobList, newRangeTableEntry); Job *dependentJob = JobForRangeTable(dependentJobList, newRangeTableEntry);
List *targetEntryList = dependedJob->jobQuery->targetList; List *targetEntryList = dependentJob->jobQuery->targetList;
ListCell *targetEntryCell = NULL; ListCell *targetEntryCell = NULL;
foreach(targetEntryCell, targetEntryList) foreach(targetEntryCell, targetEntryList)
@ -1852,12 +1854,12 @@ UniqueJobId(void)
/* Builds a job from the given job query and depended job list. */ /* Builds a job from the given job query and depended job list. */
static Job * static Job *
BuildJob(Query *jobQuery, List *dependedJobList) BuildJob(Query *jobQuery, List *dependentJobList)
{ {
Job *job = CitusMakeNode(Job); Job *job = CitusMakeNode(Job);
job->jobId = UniqueJobId(); job->jobId = UniqueJobId();
job->jobQuery = jobQuery; job->jobQuery = jobQuery;
job->dependedJobList = dependedJobList; job->dependentJobList = dependentJobList;
job->requiresMasterEvaluation = false; job->requiresMasterEvaluation = false;
return job; return job;
@ -1871,7 +1873,7 @@ BuildJob(Query *jobQuery, List *dependedJobList)
* method to apply. * method to apply.
*/ */
static MapMergeJob * static MapMergeJob *
BuildMapMergeJob(Query *jobQuery, List *dependedJobList, Var *partitionKey, BuildMapMergeJob(Query *jobQuery, List *dependentJobList, Var *partitionKey,
PartitionType partitionType, Oid baseRelationId, PartitionType partitionType, Oid baseRelationId,
BoundaryNodeJobType boundaryNodeJobType) BoundaryNodeJobType boundaryNodeJobType)
{ {
@ -1881,13 +1883,13 @@ BuildMapMergeJob(Query *jobQuery, List *dependedJobList, Var *partitionKey,
/* update the logical partition key's table and column identifiers */ /* update the logical partition key's table and column identifiers */
if (boundaryNodeJobType != SUBQUERY_MAP_MERGE_JOB) if (boundaryNodeJobType != SUBQUERY_MAP_MERGE_JOB)
{ {
UpdateColumnAttributes(partitionColumn, rangeTableList, dependedJobList); UpdateColumnAttributes(partitionColumn, rangeTableList, dependentJobList);
} }
MapMergeJob *mapMergeJob = CitusMakeNode(MapMergeJob); MapMergeJob *mapMergeJob = CitusMakeNode(MapMergeJob);
mapMergeJob->job.jobId = UniqueJobId(); mapMergeJob->job.jobId = UniqueJobId();
mapMergeJob->job.jobQuery = jobQuery; mapMergeJob->job.jobQuery = jobQuery;
mapMergeJob->job.dependedJobList = dependedJobList; mapMergeJob->job.dependentJobList = dependentJobList;
mapMergeJob->partitionColumn = partitionColumn; mapMergeJob->partitionColumn = partitionColumn;
mapMergeJob->sortedShardIntervalArrayLength = 0; mapMergeJob->sortedShardIntervalArrayLength = 0;
@ -2015,7 +2017,7 @@ BuildJobTreeTaskList(Job *jobTree, PlannerRestrictionContext *plannerRestriction
/* pop top element and push its children to the stack */ /* pop top element and push its children to the stack */
jobStack = list_delete_ptr(jobStack, job); jobStack = list_delete_ptr(jobStack, job);
jobStack = list_union_ptr(jobStack, job->dependedJobList); jobStack = list_union_ptr(jobStack, job->dependentJobList);
} }
/* /*
@ -2447,7 +2449,7 @@ QueryPushdownTaskCreate(Query *originalQuery, int shardIndex,
subqueryTask->queryString = queryString->data; subqueryTask->queryString = queryString->data;
} }
subqueryTask->dependedTaskList = NULL; subqueryTask->dependentTaskList = NULL;
subqueryTask->anchorShardId = anchorShardId; subqueryTask->anchorShardId = anchorShardId;
subqueryTask->taskPlacementList = selectPlacementList; subqueryTask->taskPlacementList = selectPlacementList;
subqueryTask->relationShardList = relationShardList; subqueryTask->relationShardList = relationShardList;
@ -2631,7 +2633,7 @@ SqlTaskList(Job *job)
Query *jobQuery = job->jobQuery; Query *jobQuery = job->jobQuery;
List *rangeTableList = jobQuery->rtable; List *rangeTableList = jobQuery->rtable;
List *whereClauseList = (List *) jobQuery->jointree->quals; List *whereClauseList = (List *) jobQuery->jointree->quals;
List *dependedJobList = job->dependedJobList; List *dependentJobList = job->dependentJobList;
/* /*
* If we don't depend on a hash partition, then we determine the largest * If we don't depend on a hash partition, then we determine the largest
@ -2668,7 +2670,7 @@ SqlTaskList(Job *job)
*/ */
List *rangeTableFragmentsList = RangeTableFragmentsList(rangeTableList, List *rangeTableFragmentsList = RangeTableFragmentsList(rangeTableList,
whereClauseList, whereClauseList,
dependedJobList); dependentJobList);
if (rangeTableFragmentsList == NIL) if (rangeTableFragmentsList == NIL)
{ {
return NIL; return NIL;
@ -2680,7 +2682,7 @@ SqlTaskList(Job *job)
* represents one SQL task's dependencies. * represents one SQL task's dependencies.
*/ */
List *fragmentCombinationList = FragmentCombinationList(rangeTableFragmentsList, List *fragmentCombinationList = FragmentCombinationList(rangeTableFragmentsList,
jobQuery, dependedJobList); jobQuery, dependentJobList);
ListCell *fragmentCombinationCell = NULL; ListCell *fragmentCombinationCell = NULL;
foreach(fragmentCombinationCell, fragmentCombinationList) foreach(fragmentCombinationCell, fragmentCombinationList)
@ -2704,7 +2706,7 @@ SqlTaskList(Job *job)
Task *sqlTask = CreateBasicTask(jobId, taskIdIndex, SQL_TASK, Task *sqlTask = CreateBasicTask(jobId, taskIdIndex, SQL_TASK,
sqlQueryString->data); sqlQueryString->data);
sqlTask->dependedTaskList = dataFetchTaskList; sqlTask->dependentTaskList = dataFetchTaskList;
sqlTask->relationShardList = BuildRelationShardList(fragmentRangeTableList, sqlTask->relationShardList = BuildRelationShardList(fragmentRangeTableList,
fragmentCombination); fragmentCombination);
@ -2736,15 +2738,15 @@ static bool
DependsOnHashPartitionJob(Job *job) DependsOnHashPartitionJob(Job *job)
{ {
bool dependsOnHashPartitionJob = false; bool dependsOnHashPartitionJob = false;
List *dependedJobList = job->dependedJobList; List *dependentJobList = job->dependentJobList;
uint32 dependedJobCount = (uint32) list_length(dependedJobList); uint32 dependentJobCount = (uint32) list_length(dependentJobList);
if (dependedJobCount > 0) if (dependentJobCount > 0)
{ {
Job *dependedJob = (Job *) linitial(dependedJobList); Job *dependentJob = (Job *) linitial(dependentJobList);
if (CitusIsA(dependedJob, MapMergeJob)) if (CitusIsA(dependentJob, MapMergeJob))
{ {
MapMergeJob *mapMergeJob = (MapMergeJob *) dependedJob; MapMergeJob *mapMergeJob = (MapMergeJob *) dependentJob;
if (mapMergeJob->partitionType == DUAL_HASH_PARTITION_TYPE) if (mapMergeJob->partitionType == DUAL_HASH_PARTITION_TYPE)
{ {
dependsOnHashPartitionJob = true; dependsOnHashPartitionJob = true;
@ -2923,7 +2925,7 @@ AdjustColumnOldAttributes(List *expressionList)
*/ */
static List * static List *
RangeTableFragmentsList(List *rangeTableList, List *whereClauseList, RangeTableFragmentsList(List *rangeTableList, List *whereClauseList,
List *dependedJobList) List *dependentJobList)
{ {
List *rangeTableFragmentsList = NIL; List *rangeTableFragmentsList = NIL;
uint32 rangeTableIndex = 0; uint32 rangeTableIndex = 0;
@ -2975,10 +2977,10 @@ RangeTableFragmentsList(List *rangeTableList, List *whereClauseList,
List *mergeTaskFragmentList = NIL; List *mergeTaskFragmentList = NIL;
ListCell *mergeTaskCell = NULL; ListCell *mergeTaskCell = NULL;
Job *dependedJob = JobForRangeTable(dependedJobList, rangeTableEntry); Job *dependentJob = JobForRangeTable(dependentJobList, rangeTableEntry);
Assert(CitusIsA(dependedJob, MapMergeJob)); Assert(CitusIsA(dependentJob, MapMergeJob));
MapMergeJob *dependedMapMergeJob = (MapMergeJob *) dependedJob; MapMergeJob *dependedMapMergeJob = (MapMergeJob *) dependentJob;
List *mergeTaskList = dependedMapMergeJob->mergeTaskList; List *mergeTaskList = dependedMapMergeJob->mergeTaskList;
/* if there are no tasks for the depended job, just return NIL */ /* if there are no tasks for the depended job, just return NIL */
@ -3328,7 +3330,7 @@ UpdateConstraint(Node *baseConstraint, ShardInterval *shardInterval)
*/ */
static List * static List *
FragmentCombinationList(List *rangeTableFragmentsList, Query *jobQuery, FragmentCombinationList(List *rangeTableFragmentsList, Query *jobQuery,
List *dependedJobList) List *dependentJobList)
{ {
List *fragmentCombinationList = NIL; List *fragmentCombinationList = NIL;
List *fragmentCombinationQueue = NIL; List *fragmentCombinationQueue = NIL;
@ -3337,7 +3339,7 @@ FragmentCombinationList(List *rangeTableFragmentsList, Query *jobQuery,
/* find a sequence that joins the range tables in the list */ /* find a sequence that joins the range tables in the list */
JoinSequenceNode *joinSequenceArray = JoinSequenceArray(rangeTableFragmentsList, JoinSequenceNode *joinSequenceArray = JoinSequenceArray(rangeTableFragmentsList,
jobQuery, jobQuery,
dependedJobList); dependentJobList);
/* /*
* We use breadth-first search with pruning to create fragment combinations. * We use breadth-first search with pruning to create fragment combinations.
@ -3432,7 +3434,7 @@ FragmentCombinationList(List *rangeTableFragmentsList, Query *jobQuery,
* range table list and the id of a preceding table with which it is joined, if any. * range table list and the id of a preceding table with which it is joined, if any.
*/ */
static JoinSequenceNode * static JoinSequenceNode *
JoinSequenceArray(List *rangeTableFragmentsList, Query *jobQuery, List *dependedJobList) JoinSequenceArray(List *rangeTableFragmentsList, Query *jobQuery, List *dependentJobList)
{ {
List *rangeTableList = jobQuery->rtable; List *rangeTableList = jobQuery->rtable;
uint32 rangeTableCount = (uint32) list_length(rangeTableList); uint32 rangeTableCount = (uint32) list_length(rangeTableList);
@ -3530,9 +3532,9 @@ JoinSequenceArray(List *rangeTableFragmentsList, Query *jobQuery, List *depended
} }
bool leftPartitioned = PartitionedOnColumn(leftColumn, rangeTableList, bool leftPartitioned = PartitionedOnColumn(leftColumn, rangeTableList,
dependedJobList); dependentJobList);
bool rightPartitioned = PartitionedOnColumn(rightColumn, rangeTableList, bool rightPartitioned = PartitionedOnColumn(rightColumn, rangeTableList,
dependedJobList); dependentJobList);
if (leftPartitioned && rightPartitioned) if (leftPartitioned && rightPartitioned)
{ {
/* make sure this join clause references only simple columns */ /* make sure this join clause references only simple columns */
@ -3570,7 +3572,7 @@ JoinSequenceArray(List *rangeTableFragmentsList, Query *jobQuery, List *depended
* relation is a reference table. * relation is a reference table.
*/ */
static bool static bool
PartitionedOnColumn(Var *column, List *rangeTableList, List *dependedJobList) PartitionedOnColumn(Var *column, List *rangeTableList, List *dependentJobList)
{ {
bool partitionedOnColumn = false; bool partitionedOnColumn = false;
Index rangeTableId = column->varno; Index rangeTableId = column->varno;
@ -3598,7 +3600,7 @@ PartitionedOnColumn(Var *column, List *rangeTableList, List *dependedJobList)
} }
else if (rangeTableType == CITUS_RTE_REMOTE_QUERY) else if (rangeTableType == CITUS_RTE_REMOTE_QUERY)
{ {
Job *job = JobForRangeTable(dependedJobList, rangeTableEntry); Job *job = JobForRangeTable(dependentJobList, rangeTableEntry);
MapMergeJob *mapMergeJob = (MapMergeJob *) job; MapMergeJob *mapMergeJob = (MapMergeJob *) job;
/* /*
@ -3857,7 +3859,7 @@ DataFetchTaskList(uint64 jobId, uint32 taskIdIndex, List *fragmentList)
/* create merge fetch task and have it depend on the merge task */ /* create merge fetch task and have it depend on the merge task */
Task *mergeFetchTask = CreateBasicTask(jobId, taskIdIndex, MERGE_FETCH_TASK, Task *mergeFetchTask = CreateBasicTask(jobId, taskIdIndex, MERGE_FETCH_TASK,
undefinedQueryString); undefinedQueryString);
mergeFetchTask->dependedTaskList = list_make1(mergeTask); mergeFetchTask->dependentTaskList = list_make1(mergeTask);
dataFetchTaskList = lappend(dataFetchTaskList, mergeFetchTask); dataFetchTaskList = lappend(dataFetchTaskList, mergeFetchTask);
taskIdIndex++; taskIdIndex++;
@ -4089,13 +4091,13 @@ PruneSqlTaskDependencies(List *sqlTaskList)
foreach(sqlTaskCell, sqlTaskList) foreach(sqlTaskCell, sqlTaskList)
{ {
Task *sqlTask = (Task *) lfirst(sqlTaskCell); Task *sqlTask = (Task *) lfirst(sqlTaskCell);
List *dependedTaskList = sqlTask->dependedTaskList; List *dependentTaskList = sqlTask->dependentTaskList;
List *prunedDependedTaskList = NIL; List *prunedDependendTaskList = NIL;
ListCell *dependedTaskCell = NULL; ListCell *dependentTaskCell = NULL;
foreach(dependedTaskCell, dependedTaskList) foreach(dependentTaskCell, dependentTaskList)
{ {
Task *dataFetchTask = (Task *) lfirst(dependedTaskCell); Task *dataFetchTask = (Task *) lfirst(dependentTaskCell);
/* /*
* If we have a merge fetch task, our task assignment algorithm makes * If we have a merge fetch task, our task assignment algorithm makes
@ -4104,12 +4106,12 @@ PruneSqlTaskDependencies(List *sqlTaskList)
*/ */
if (dataFetchTask->taskType == MERGE_FETCH_TASK) if (dataFetchTask->taskType == MERGE_FETCH_TASK)
{ {
List *mergeFetchDependencyList = dataFetchTask->dependedTaskList; List *mergeFetchDependencyList = dataFetchTask->dependentTaskList;
Assert(list_length(mergeFetchDependencyList) == 1); Assert(list_length(mergeFetchDependencyList) == 1);
Task *mergeTaskReference = (Task *) linitial(mergeFetchDependencyList); Task *mergeTaskReference = (Task *) linitial(mergeFetchDependencyList);
prunedDependedTaskList = lappend(prunedDependedTaskList, prunedDependendTaskList = lappend(prunedDependendTaskList,
mergeTaskReference); mergeTaskReference);
ereport(DEBUG2, (errmsg("pruning merge fetch taskId %d", ereport(DEBUG2, (errmsg("pruning merge fetch taskId %d",
dataFetchTask->taskId), dataFetchTask->taskId),
@ -4118,7 +4120,7 @@ PruneSqlTaskDependencies(List *sqlTaskList)
} }
} }
sqlTask->dependedTaskList = prunedDependedTaskList; sqlTask->dependentTaskList = prunedDependendTaskList;
} }
return sqlTaskList; return sqlTaskList;
@ -4469,14 +4471,14 @@ MergeTaskList(MapMergeJob *mapMergeJob, List *mapTaskList, uint32 taskIdIndex)
undefinedQueryString); undefinedQueryString);
mapOutputFetchTask->partitionId = partitionId; mapOutputFetchTask->partitionId = partitionId;
mapOutputFetchTask->upstreamTaskId = mergeTaskId; mapOutputFetchTask->upstreamTaskId = mergeTaskId;
mapOutputFetchTask->dependedTaskList = list_make1(mapTask); mapOutputFetchTask->dependentTaskList = list_make1(mapTask);
taskIdIndex++; taskIdIndex++;
mapOutputFetchTaskList = lappend(mapOutputFetchTaskList, mapOutputFetchTask); mapOutputFetchTaskList = lappend(mapOutputFetchTaskList, mapOutputFetchTask);
} }
/* merge task depends on completion of fetch tasks */ /* merge task depends on completion of fetch tasks */
mergeTask->dependedTaskList = mapOutputFetchTaskList; mergeTask->dependentTaskList = mapOutputFetchTaskList;
/* if single repartitioned, each merge task represents an interval */ /* if single repartitioned, each merge task represents an interval */
if (mapMergeJob->partitionType == RANGE_PARTITION_TYPE) if (mapMergeJob->partitionType == RANGE_PARTITION_TYPE)
@ -4710,13 +4712,13 @@ HasMergeTaskDependencies(List *sqlTaskList)
{ {
bool hasMergeTaskDependencies = false; bool hasMergeTaskDependencies = false;
Task *sqlTask = (Task *) linitial(sqlTaskList); Task *sqlTask = (Task *) linitial(sqlTaskList);
List *dependedTaskList = sqlTask->dependedTaskList; List *dependentTaskList = sqlTask->dependentTaskList;
ListCell *dependedTaskCell = NULL; ListCell *dependentTaskCell = NULL;
foreach(dependedTaskCell, dependedTaskList) foreach(dependentTaskCell, dependentTaskList)
{ {
Task *dependedTask = (Task *) lfirst(dependedTaskCell); Task *dependentTask = (Task *) lfirst(dependentTaskCell);
if (dependedTask->taskType == MERGE_TASK) if (dependentTask->taskType == MERGE_TASK)
{ {
hasMergeTaskDependencies = true; hasMergeTaskDependencies = true;
break; break;
@ -5291,15 +5293,15 @@ static List *
FindDependedMergeTaskList(Task *sqlTask) FindDependedMergeTaskList(Task *sqlTask)
{ {
List *dependedMergeTaskList = NIL; List *dependedMergeTaskList = NIL;
List *dependedTaskList = sqlTask->dependedTaskList; List *dependentTaskList = sqlTask->dependentTaskList;
ListCell *dependedTaskCell = NULL; ListCell *dependentTaskCell = NULL;
foreach(dependedTaskCell, dependedTaskList) foreach(dependentTaskCell, dependentTaskList)
{ {
Task *dependedTask = (Task *) lfirst(dependedTaskCell); Task *dependentTask = (Task *) lfirst(dependentTaskCell);
if (dependedTask->taskType == MERGE_TASK) if (dependentTask->taskType == MERGE_TASK)
{ {
dependedMergeTaskList = lappend(dependedMergeTaskList, dependedTask); dependedMergeTaskList = lappend(dependedMergeTaskList, dependentTask);
} }
} }
@ -5398,18 +5400,18 @@ AssignDataFetchDependencies(List *taskList)
foreach(taskCell, taskList) foreach(taskCell, taskList)
{ {
Task *task = (Task *) lfirst(taskCell); Task *task = (Task *) lfirst(taskCell);
List *dependedTaskList = task->dependedTaskList; List *dependentTaskList = task->dependentTaskList;
ListCell *dependedTaskCell = NULL; ListCell *dependentTaskCell = NULL;
Assert(task->taskPlacementList != NIL); Assert(task->taskPlacementList != NIL);
Assert(task->taskType == SQL_TASK || task->taskType == MERGE_TASK); Assert(task->taskType == SQL_TASK || task->taskType == MERGE_TASK);
foreach(dependedTaskCell, dependedTaskList) foreach(dependentTaskCell, dependentTaskList)
{ {
Task *dependedTask = (Task *) lfirst(dependedTaskCell); Task *dependentTask = (Task *) lfirst(dependentTaskCell);
if (dependedTask->taskType == MAP_OUTPUT_FETCH_TASK) if (dependentTask->taskType == MAP_OUTPUT_FETCH_TASK)
{ {
dependedTask->taskPlacementList = task->taskPlacementList; dependentTask->taskPlacementList = task->taskPlacementList;
} }
} }
} }

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

@ -1453,7 +1453,7 @@ CreateJob(Query *query)
job->jobId = UniqueJobId(); job->jobId = UniqueJobId();
job->jobQuery = query; job->jobQuery = query;
job->taskList = NIL; job->taskList = NIL;
job->dependedJobList = NIL; job->dependentJobList = NIL;
job->subqueryPushdown = false; job->subqueryPushdown = false;
job->requiresMasterEvaluation = false; job->requiresMasterEvaluation = false;
job->deferredPruning = false; job->deferredPruning = false;
@ -1575,7 +1575,7 @@ CreateTask(TaskType taskType)
task->queryString = NULL; task->queryString = NULL;
task->anchorShardId = INVALID_SHARD_ID; task->anchorShardId = INVALID_SHARD_ID;
task->taskPlacementList = NIL; task->taskPlacementList = NIL;
task->dependedTaskList = NIL; task->dependentTaskList = NIL;
task->partitionId = 0; task->partitionId = 0;
task->upstreamTaskId = INVALID_TASK_ID; task->upstreamTaskId = INVALID_TASK_ID;

4
src/backend/distributed/utils/citus_copyfuncs.c
View File

@ -80,7 +80,7 @@ copyJobInfo(Job *newnode, Job *from)
COPY_SCALAR_FIELD(jobId); COPY_SCALAR_FIELD(jobId);
COPY_NODE_FIELD(jobQuery); COPY_NODE_FIELD(jobQuery);
COPY_NODE_FIELD(taskList); COPY_NODE_FIELD(taskList);
COPY_NODE_FIELD(dependedJobList); COPY_NODE_FIELD(dependentJobList);
COPY_SCALAR_FIELD(subqueryPushdown); COPY_SCALAR_FIELD(subqueryPushdown);
COPY_SCALAR_FIELD(requiresMasterEvaluation); COPY_SCALAR_FIELD(requiresMasterEvaluation);
COPY_SCALAR_FIELD(deferredPruning); COPY_SCALAR_FIELD(deferredPruning);
@ -251,7 +251,7 @@ CopyNodeTask(COPYFUNC_ARGS)
COPY_STRING_FIELD(queryString); COPY_STRING_FIELD(queryString);
COPY_SCALAR_FIELD(anchorShardId); COPY_SCALAR_FIELD(anchorShardId);
COPY_NODE_FIELD(taskPlacementList); COPY_NODE_FIELD(taskPlacementList);
COPY_NODE_FIELD(dependedTaskList); COPY_NODE_FIELD(dependentTaskList);
COPY_SCALAR_FIELD(partitionId); COPY_SCALAR_FIELD(partitionId);
COPY_SCALAR_FIELD(upstreamTaskId); COPY_SCALAR_FIELD(upstreamTaskId);
COPY_NODE_FIELD(shardInterval); COPY_NODE_FIELD(shardInterval);

4
src/backend/distributed/utils/citus_outfuncs.c
View File

@ -323,7 +323,7 @@ OutJobFields(StringInfo str, const Job *node)
WRITE_UINT64_FIELD(jobId); WRITE_UINT64_FIELD(jobId);
WRITE_NODE_FIELD(jobQuery); WRITE_NODE_FIELD(jobQuery);
WRITE_NODE_FIELD(taskList); WRITE_NODE_FIELD(taskList);
WRITE_NODE_FIELD(dependedJobList); WRITE_NODE_FIELD(dependentJobList);
WRITE_BOOL_FIELD(subqueryPushdown); WRITE_BOOL_FIELD(subqueryPushdown);
WRITE_BOOL_FIELD(requiresMasterEvaluation); WRITE_BOOL_FIELD(requiresMasterEvaluation);
WRITE_BOOL_FIELD(deferredPruning); WRITE_BOOL_FIELD(deferredPruning);
@ -467,7 +467,7 @@ OutTask(OUTFUNC_ARGS)
WRITE_STRING_FIELD(queryString); WRITE_STRING_FIELD(queryString);
WRITE_UINT64_FIELD(anchorShardId); WRITE_UINT64_FIELD(anchorShardId);
WRITE_NODE_FIELD(taskPlacementList); WRITE_NODE_FIELD(taskPlacementList);
WRITE_NODE_FIELD(dependedTaskList); WRITE_NODE_FIELD(dependentTaskList);
WRITE_UINT_FIELD(partitionId); WRITE_UINT_FIELD(partitionId);
WRITE_UINT_FIELD(upstreamTaskId); WRITE_UINT_FIELD(upstreamTaskId);
WRITE_NODE_FIELD(shardInterval); WRITE_NODE_FIELD(shardInterval);

4
src/backend/distributed/utils/citus_readfuncs.c
View File

@ -184,7 +184,7 @@ readJobInfo(Job *local_node)
READ_UINT64_FIELD(jobId); READ_UINT64_FIELD(jobId);
READ_NODE_FIELD(jobQuery); READ_NODE_FIELD(jobQuery);
READ_NODE_FIELD(taskList); READ_NODE_FIELD(taskList);
READ_NODE_FIELD(dependedJobList); READ_NODE_FIELD(dependentJobList);
READ_BOOL_FIELD(subqueryPushdown); READ_BOOL_FIELD(subqueryPushdown);
READ_BOOL_FIELD(requiresMasterEvaluation); READ_BOOL_FIELD(requiresMasterEvaluation);
READ_BOOL_FIELD(deferredPruning); READ_BOOL_FIELD(deferredPruning);
@ -381,7 +381,7 @@ ReadTask(READFUNC_ARGS)
READ_STRING_FIELD(queryString); READ_STRING_FIELD(queryString);
READ_UINT64_FIELD(anchorShardId); READ_UINT64_FIELD(anchorShardId);
READ_NODE_FIELD(taskPlacementList); READ_NODE_FIELD(taskPlacementList);
READ_NODE_FIELD(dependedTaskList); READ_NODE_FIELD(dependentTaskList);
READ_UINT_FIELD(partitionId); READ_UINT_FIELD(partitionId);
READ_UINT_FIELD(upstreamTaskId); READ_UINT_FIELD(upstreamTaskId);
READ_NODE_FIELD(shardInterval); READ_NODE_FIELD(shardInterval);

4
src/include/distributed/multi_physical_planner.h
View File

@ -132,7 +132,7 @@ typedef struct Job
uint64 jobId; uint64 jobId;
Query *jobQuery; Query *jobQuery;
List *taskList; List *taskList;
List *dependedJobList; List *dependentJobList;
bool subqueryPushdown; bool subqueryPushdown;
bool requiresMasterEvaluation; /* only applies to modify jobs */ bool requiresMasterEvaluation; /* only applies to modify jobs */
bool deferredPruning; bool deferredPruning;
@ -185,7 +185,7 @@ typedef struct Task
char *queryString; char *queryString;
uint64 anchorShardId; /* only applies to compute tasks */ uint64 anchorShardId; /* only applies to compute tasks */
List *taskPlacementList; /* only applies to compute tasks */ List *taskPlacementList; /* only applies to compute tasks */
List *dependedTaskList; /* only applies to compute tasks */ List *dependentTaskList; /* only applies to compute tasks */
uint32 partitionId; uint32 partitionId;
uint32 upstreamTaskId; /* only applies to data fetch tasks */ uint32 upstreamTaskId; /* only applies to data fetch tasks */