Function create_append_path

src/backend/optimizer/util/pathnode.c:1394–1527

* create_append_path * Creates a path corresponding to an Append plan, returning the * pathnode. * * Note that we must handle subpaths = NIL, representing a dummy access path. * Also, there are callers that pass root = NULL. */

 * Also, there are callers that pass root = NULL.
 */
AppendPath *
create_append_path(PlannerInfo *root,
				   RelOptInfo *rel,
				   List *subpaths, List *partial_subpaths,
				   List *pathkeys, Relids required_outer,
				   int parallel_workers, bool parallel_aware,
				   double rows)
{
	AppendPath *pathnode = makeNode(AppendPath);
	ListCell   *l;

	/*
	 * CBDB_PARALLEL_FIXME: it still cannot be opened after we deal with append.
	 * Because we currently allow path with non parallel_workers been added to
	 * partial_path.
	 */
#if 0
	Assert(!parallel_aware || parallel_workers > 0);
#endif


	pathnode->path.pathtype = T_Append;
	pathnode->path.parent = rel;
	pathnode->path.pathtarget = rel->reltarget;

	/*
	 * When generating an Append path for a partitioned table, there may be
	 * parameterized quals that are useful for run-time pruning.  Hence,
	 * compute path.param_info the same way as for any other baserel, so that
	 * such quals will be available for make_partition_pruneinfo().  (This
	 * would not work right for a non-baserel, ie a scan on a non-leaf child
	 * partition, and it's not necessary anyway in that case.  Must skip it if
	 * we don't have "root", too.)
	 */
	if (root && rel->reloptkind == RELOPT_BASEREL && IS_PARTITIONED_REL(rel))
		pathnode->path.param_info = get_baserel_parampathinfo(root,
															  rel,
															  required_outer);
	else
		pathnode->path.param_info = get_appendrel_parampathinfo(rel,
																required_outer);

	pathnode->path.parallel_aware = parallel_aware;
	pathnode->path.parallel_safe = rel->consider_parallel;
	pathnode->path.parallel_workers = parallel_workers;
	pathnode->path.pathkeys = pathkeys;

	pathnode->path.motionHazard = false;
	pathnode->path.barrierHazard = false;
	pathnode->path.rescannable = true;

	/*
	 * For parallel append, non-partial paths are sorted by descending total
	 * costs. That way, the total time to finish all non-partial paths is
	 * minimized.  Also, the partial paths are sorted by descending startup
	 * costs.  There may be some paths that require to do startup work by a
	 * single worker.  In such case, it's better for workers to choose the
	 * expensive ones first, whereas the leader should choose the cheapest