if (fpinfo->jointype == JOIN_INNER)
{
*ignore_conds = list_concat(*ignore_conds,
- list_copy(fpinfo->joinclauses));
+ fpinfo->joinclauses);
fpinfo->joinclauses = NIL;
}
* baserestrictinfo plus any extra join_conds relevant to this
* particular path.
*/
- remote_conds = list_concat(list_copy(remote_param_join_conds),
+ remote_conds = list_concat(remote_param_join_conds,
fpinfo->remote_conds);
/*
{
case JOIN_INNER:
fpinfo->remote_conds = list_concat(fpinfo->remote_conds,
- list_copy(fpinfo_i->remote_conds));
+ fpinfo_i->remote_conds);
fpinfo->remote_conds = list_concat(fpinfo->remote_conds,
- list_copy(fpinfo_o->remote_conds));
+ fpinfo_o->remote_conds);
break;
case JOIN_LEFT:
fpinfo->joinclauses = list_concat(fpinfo->joinclauses,
- list_copy(fpinfo_i->remote_conds));
+ fpinfo_i->remote_conds);
fpinfo->remote_conds = list_concat(fpinfo->remote_conds,
- list_copy(fpinfo_o->remote_conds));
+ fpinfo_o->remote_conds);
break;
case JOIN_RIGHT:
fpinfo->joinclauses = list_concat(fpinfo->joinclauses,
- list_copy(fpinfo_o->remote_conds));
+ fpinfo_o->remote_conds);
fpinfo->remote_conds = list_concat(fpinfo->remote_conds,
- list_copy(fpinfo_i->remote_conds));
+ fpinfo_i->remote_conds);
break;
case JOIN_FULL:
* is part of the key columns, and anything equal to and over is part of
* the INCLUDE columns.
*/
- allIndexParams = list_concat(list_copy(stmt->indexParams),
- list_copy(stmt->indexIncludingParams));
+ allIndexParams = list_concat_copy(stmt->indexParams,
+ stmt->indexIncludingParams);
numberOfAttributes = list_length(allIndexParams);
if (numberOfAttributes <= 0)
fcache->pinfo,
NULL);
queryTree_list = lappend(queryTree_list, queryTree_sublist);
- flat_query_list = list_concat(flat_query_list,
- list_copy(queryTree_sublist));
+ flat_query_list = list_concat(flat_query_list, queryTree_sublist);
}
check_sql_fn_statements(flat_query_list);
}
/*
- * Concatenate list2 to the end of list1, and return list1. list1 is
- * destructively changed, list2 is not. (However, in the case of pointer
- * lists, list1 and list2 will point to the same structures.) Callers
- * should be sure to use the return value as the new pointer to the
- * concatenated list: the 'list1' input pointer may or may not be the
- * same as the returned pointer.
+ * Concatenate list2 to the end of list1, and return list1.
+ *
+ * This is equivalent to lappend'ing each element of list2, in order, to list1.
+ * list1 is destructively changed, list2 is not. (However, in the case of
+ * pointer lists, list1 and list2 will point to the same structures.)
+ *
+ * Callers should be sure to use the return value as the new pointer to the
+ * concatenated list: the 'list1' input pointer may or may not be the same
+ * as the returned pointer.
*/
List *
list_concat(List *list1, const List *list2)
return list1;
}
+/*
+ * Form a new list by concatenating the elements of list1 and list2.
+ *
+ * Neither input list is modified. (However, if they are pointer lists,
+ * the output list will point to the same structures.)
+ *
+ * This is equivalent to, but more efficient than,
+ * list_concat(list_copy(list1), list2).
+ * Note that some pre-v13 code might list_copy list2 as well, but that's
+ * pointless now.
+ */
+List *
+list_concat_copy(const List *list1, const List *list2)
+{
+ List *result;
+ int new_len;
+
+ if (list1 == NIL)
+ return list_copy(list2);
+ if (list2 == NIL)
+ return list_copy(list1);
+
+ Assert(list1->type == list2->type);
+
+ new_len = list1->length + list2->length;
+ result = new_list(list1->type, new_len);
+ memcpy(result->elements, list1->elements,
+ list1->length * sizeof(ListCell));
+ memcpy(result->elements + list1->length, list2->elements,
+ list2->length * sizeof(ListCell));
+
+ check_list_invariants(result);
+ return result;
+}
+
/*
* Truncate 'list' to contain no more than 'new_size' elements. This
* modifies the list in-place! Despite this, callers should use the
if (rel->part_scheme)
rel->partitioned_child_rels =
list_concat(rel->partitioned_child_rels,
- list_copy(childrel->partitioned_child_rels));
+ childrel->partitioned_child_rels);
/*
* Child is live, so add it to the live_childrels list for use below.
component = root->simple_rel_array[relid];
Assert(component->part_scheme != NULL);
Assert(list_length(component->partitioned_child_rels) >= 1);
- partrels =
- list_concat(partrels,
- list_copy(component->partitioned_child_rels));
+ partrels = list_concat(partrels,
+ component->partitioned_child_rels);
}
partitioned_rels = list_make1(partrels);
if (!apath->path.parallel_aware || apath->first_partial_path == 0)
{
- /* list_copy is important here to avoid sharing list substructure */
- *subpaths = list_concat(*subpaths, list_copy(apath->subpaths));
+ *subpaths = list_concat(*subpaths, apath->subpaths);
return;
}
else if (special_subpaths != NULL)
{
MergeAppendPath *mpath = (MergeAppendPath *) path;
- /* list_copy is important here to avoid sharing list substructure */
- *subpaths = list_concat(*subpaths, list_copy(mpath->subpaths));
+ *subpaths = list_concat(*subpaths, mpath->subpaths);
return;
}
* restriction clauses. Note that we force the clauses to be treated as
* non-join clauses during selectivity estimation.
*/
- allclauses = list_concat(list_copy(param_clauses),
- rel->baserestrictinfo);
+ allclauses = list_concat_copy(param_clauses, rel->baserestrictinfo);
nrows = rel->tuples *
clauselist_selectivity(root,
allclauses,
}
}
- /* Add restriction clauses (this is nondestructive to rclauseset) */
+ /* Add restriction clauses */
clauseset.indexclauses[indexcol] =
list_concat(clauseset.indexclauses[indexcol],
rclauseset->indexclauses[indexcol]);
{
/* Form all_clauses if not done already */
if (all_clauses == NIL)
- all_clauses = list_concat(list_copy(clauses),
- other_clauses);
+ all_clauses = list_concat_copy(clauses, other_clauses);
if (!predicate_implied_by(index->indpred, all_clauses, false))
continue; /* can't use it at all */
* We can use both the current and other clauses as context for
* build_paths_for_OR; no need to remove ORs from the lists.
*/
- all_clauses = list_concat(list_copy(clauses), other_clauses);
+ all_clauses = list_concat_copy(clauses, other_clauses);
foreach(lc, clauses)
{
pathinfo = pathinfoarray[i];
paths = list_make1(pathinfo->path);
costsofar = bitmap_scan_cost_est(root, rel, pathinfo->path);
- qualsofar = list_concat(list_copy(pathinfo->quals),
- list_copy(pathinfo->preds));
+ qualsofar = list_concat_copy(pathinfo->quals, pathinfo->preds);
clauseidsofar = bms_copy(pathinfo->clauseids);
for (j = i + 1; j < npaths; j++)
{
/* keep new path in paths, update subsidiary variables */
costsofar = newcost;
- qualsofar = list_concat(qualsofar,
- list_copy(pathinfo->quals));
- qualsofar = list_concat(qualsofar,
- list_copy(pathinfo->preds));
+ qualsofar = list_concat(qualsofar, pathinfo->quals);
+ qualsofar = list_concat(qualsofar, pathinfo->preds);
clauseidsofar = bms_add_members(clauseidsofar,
pathinfo->clauseids);
}
*quals = lappend(*quals, iclause->rinfo->clause);
}
- *preds = list_concat(*preds, list_copy(ipath->indexinfo->indpred));
+ *preds = list_concat(*preds, ipath->indexinfo->indpred);
}
else
elog(ERROR, "unrecognized node type: %d", nodeTag(bitmapqual));
* For paranoia's sake, don't modify the stored baserestrictinfo list.
*/
if (best_path->param_info)
- scan_clauses = list_concat(list_copy(scan_clauses),
- best_path->param_info->ppi_clauses);
+ scan_clauses = list_concat_copy(scan_clauses,
+ best_path->param_info->ppi_clauses);
/*
* Detect whether we have any pseudoconstant quals to deal with. Then, if
*postponed_qual_list = lappend(*postponed_qual_list, pq);
}
}
- /* list_concat is nondestructive of its second argument */
my_quals = list_concat(my_quals, (List *) j->quals);
/*
}
}
- /*
- * Safe to use list_concat (which shares cells of the second arg)
- * because we know that new_elems does not share cells with anything.
- */
previous = list_concat(previous, new_elems);
gs->set = list_copy(previous);
*/
if (!rollup->hashable)
return;
- else
- sets_data = list_concat(sets_data, list_copy(rollup->gsets_data));
+
+ sets_data = list_concat(sets_data, rollup->gsets_data);
}
foreach(lc, sets_data)
{
{
if (bms_is_member(i, hash_items))
hash_sets = list_concat(hash_sets,
- list_copy(rollup->gsets_data));
+ rollup->gsets_data);
else
rollups = lappend(rollups, rollup);
++i;
errdetail("Window ordering columns must be of sortable datatypes.")));
/* Okay, make the combined pathkeys */
- window_sortclauses = list_concat(list_copy(wc->partitionClause),
- list_copy(wc->orderClause));
+ window_sortclauses = list_concat_copy(wc->partitionClause, wc->orderClause);
window_pathkeys = make_pathkeys_for_sortclauses(root,
window_sortclauses,
tlist);
splan->resultRelIndex = list_length(root->glob->resultRelations);
root->glob->resultRelations =
list_concat(root->glob->resultRelations,
- list_copy(splan->resultRelations));
+ splan->resultRelations);
/*
* If the main target relation is a partitioned table, also
pass_nonnullable_rels = find_nonnullable_rels(f->quals);
pass_nonnullable_rels = bms_add_members(pass_nonnullable_rels,
nonnullable_rels);
- /* NB: we rely on list_concat to not damage its second argument */
pass_nonnullable_vars = find_nonnullable_vars(f->quals);
pass_nonnullable_vars = list_concat(pass_nonnullable_vars,
nonnullable_vars);
{
Node *subexpr = (Node *) lfirst(arg);
- /*
- * Note: we can destructively concat the subexpression's arglist
- * because we know the recursive invocation of pull_ands will have
- * built a new arglist not shared with any other expr. Otherwise we'd
- * need a list_copy here.
- */
if (is_andclause(subexpr))
out_list = list_concat(out_list,
pull_ands(((BoolExpr *) subexpr)->args));
{
Node *subexpr = (Node *) lfirst(arg);
- /*
- * Note: we can destructively concat the subexpression's arglist
- * because we know the recursive invocation of pull_ors will have
- * built a new arglist not shared with any other expr. Otherwise we'd
- * need a list_copy here.
- */
if (is_orclause(subexpr))
out_list = list_concat(out_list,
pull_ors(((BoolExpr *) subexpr)->args));
max_parallel_hazard_test(PROPARALLEL_RESTRICTED, context))
return true;
save_safe_param_ids = context->safe_param_ids;
- context->safe_param_ids = list_concat(list_copy(subplan->paramIds),
- context->safe_param_ids);
+ context->safe_param_ids = list_concat_copy(context->safe_param_ids,
+ subplan->paramIds);
if (max_parallel_hazard_walker(subplan->testexpr, context))
return true; /* no need to restore safe_param_ids */
list_free(context->safe_param_ids);
/* flatten nested ORs as per above comment */
if (is_orclause(arg))
{
- List *subargs = list_copy(((BoolExpr *) arg)->args);
+ List *subargs = ((BoolExpr *) arg)->args;
+ List *oldlist = unprocessed_args;
- /* overly tense code to avoid leaking unused list header */
- if (!unprocessed_args)
- unprocessed_args = subargs;
- else
- {
- List *oldhdr = unprocessed_args;
-
- unprocessed_args = list_concat(subargs, unprocessed_args);
- pfree(oldhdr);
- }
+ unprocessed_args = list_concat_copy(subargs, unprocessed_args);
+ /* perhaps-overly-tense code to avoid leaking old lists */
+ list_free(oldlist);
continue;
}
/*
* It is unlikely but not impossible for simplification of a non-OR
* clause to produce an OR. Recheck, but don't be too tense about it
- * since it's not a mainstream case. In particular we don't worry
- * about const-simplifying the input twice.
+ * since it's not a mainstream case. In particular we don't worry
+ * about const-simplifying the input twice, nor about list leakage.
*/
if (is_orclause(arg))
{
- List *subargs = list_copy(((BoolExpr *) arg)->args);
+ List *subargs = ((BoolExpr *) arg)->args;
- unprocessed_args = list_concat(subargs, unprocessed_args);
+ unprocessed_args = list_concat_copy(subargs, unprocessed_args);
continue;
}
/* flatten nested ANDs as per above comment */
if (is_andclause(arg))
{
- List *subargs = list_copy(((BoolExpr *) arg)->args);
+ List *subargs = ((BoolExpr *) arg)->args;
+ List *oldlist = unprocessed_args;
- /* overly tense code to avoid leaking unused list header */
- if (!unprocessed_args)
- unprocessed_args = subargs;
- else
- {
- List *oldhdr = unprocessed_args;
-
- unprocessed_args = list_concat(subargs, unprocessed_args);
- pfree(oldhdr);
- }
+ unprocessed_args = list_concat_copy(subargs, unprocessed_args);
+ /* perhaps-overly-tense code to avoid leaking old lists */
+ list_free(oldlist);
continue;
}
/*
* It is unlikely but not impossible for simplification of a non-AND
* clause to produce an AND. Recheck, but don't be too tense about it
- * since it's not a mainstream case. In particular we don't worry
- * about const-simplifying the input twice.
+ * since it's not a mainstream case. In particular we don't worry
+ * about const-simplifying the input twice, nor about list leakage.
*/
if (is_andclause(arg))
{
- List *subargs = list_copy(((BoolExpr *) arg)->args);
+ List *subargs = ((BoolExpr *) arg)->args;
- unprocessed_args = list_concat(subargs, unprocessed_args);
+ unprocessed_args = list_concat_copy(subargs, unprocessed_args);
continue;
}
defaults = list_copy_tail(defaults, ndelete);
/* And form the combined argument list, not modifying the input list */
- return list_concat(list_copy(args), defaults);
+ return list_concat_copy(args, defaults);
}
/*
subclause = (Node *) make_ands_explicit(subclauses);
if (is_orclause(subclause))
clauselist = list_concat(clauselist,
- list_copy(((BoolExpr *) subclause)->args));
+ ((BoolExpr *) subclause)->args);
else
clauselist = lappend(clauselist, subclause);
}
*/
for (cnt = 0; cnt < partnatts; cnt++)
{
- List *outer_expr;
- List *outer_null_expr;
- List *inner_expr;
- List *inner_null_expr;
+ /* mark these const to enforce that we copy them properly */
+ const List *outer_expr = outer_rel->partexprs[cnt];
+ const List *outer_null_expr = outer_rel->nullable_partexprs[cnt];
+ const List *inner_expr = inner_rel->partexprs[cnt];
+ const List *inner_null_expr = inner_rel->nullable_partexprs[cnt];
List *partexpr = NIL;
List *nullable_partexpr = NIL;
- outer_expr = list_copy(outer_rel->partexprs[cnt]);
- outer_null_expr = list_copy(outer_rel->nullable_partexprs[cnt]);
- inner_expr = list_copy(inner_rel->partexprs[cnt]);
- inner_null_expr = list_copy(inner_rel->nullable_partexprs[cnt]);
-
switch (jointype)
{
case JOIN_INNER:
- partexpr = list_concat(outer_expr, inner_expr);
- nullable_partexpr = list_concat(outer_null_expr,
- inner_null_expr);
+ partexpr = list_concat_copy(outer_expr, inner_expr);
+ nullable_partexpr = list_concat_copy(outer_null_expr,
+ inner_null_expr);
break;
case JOIN_SEMI:
case JOIN_ANTI:
- partexpr = outer_expr;
- nullable_partexpr = outer_null_expr;
+ partexpr = list_copy(outer_expr);
+ nullable_partexpr = list_copy(outer_null_expr);
break;
case JOIN_LEFT:
- partexpr = outer_expr;
- nullable_partexpr = list_concat(inner_expr,
- outer_null_expr);
+ partexpr = list_copy(outer_expr);
+ nullable_partexpr = list_concat_copy(inner_expr,
+ outer_null_expr);
nullable_partexpr = list_concat(nullable_partexpr,
inner_null_expr);
break;
case JOIN_FULL:
- nullable_partexpr = list_concat(outer_expr,
- inner_expr);
+ nullable_partexpr = list_concat_copy(outer_expr,
+ inner_expr);
nullable_partexpr = list_concat(nullable_partexpr,
outer_null_expr);
nullable_partexpr = list_concat(nullable_partexpr,
* copy_pathtarget
* Copy a PathTarget.
*
- * The new PathTarget has its own List cells, but shares the underlying
- * target expression trees with the old one. We duplicate the List cells
- * so that items can be added to one target without damaging the other.
+ * The new PathTarget has its own exprs List, but shares the underlying
+ * target expression trees with the old one.
*/
PathTarget *
copy_pathtarget(PathTarget *src)
Assert(gs_current->kind == GROUPING_SET_SIMPLE);
- current_result
- = list_concat(current_result,
- list_copy(gs_current->content));
+ current_result = list_concat(current_result,
+ gs_current->content);
/* If we are done with making the current group, break */
if (--i == 0)
Assert(gs_current->kind == GROUPING_SET_SIMPLE);
if (mask & i)
- {
- current_result
- = list_concat(current_result,
- list_copy(gs_current->content));
- }
+ current_result = list_concat(current_result,
+ gs_current->content);
mask <<= 1;
}
*
* Notice that we don't require the merged namespace list to be
* conflict-free. See the comments for scanNameSpaceForRefname().
- *
- * NB: this coding relies on the fact that list_concat is not
- * destructive to its second argument.
*/
lateral_ok = (j->jointype == JOIN_INNER || j->jointype == JOIN_LEFT);
setNamespaceLateralState(l_namespace, true, lateral_ok);
if (IsA(n1, GroupingSet) &&
((GroupingSet *) n1)->kind == GROUPING_SET_SETS)
- {
result_set = list_concat(result_set, (List *) n2);
- }
else
result_set = lappend(result_set, n2);
}
if (rel->relid != 1)
ChangeVarNodes((Node *) partqual, 1, rel->relid, 0);
- /* Use list_copy to avoid modifying the passed-in List */
- clauses = list_concat(list_copy(clauses), partqual);
+ /* Make a copy to avoid modifying the passed-in List */
+ clauses = list_concat_copy(clauses, partqual);
}
/* Down into the rabbit-hole. */
pc->keyno,
NULL,
prefix);
- opsteps = list_concat(opsteps, list_copy(pc_steps));
+ opsteps = list_concat(opsteps, pc_steps);
}
}
break;
pc->keyno,
nullkeys,
prefix);
- opsteps = list_concat(opsteps, list_copy(pc_steps));
+ opsteps = list_concat(opsteps, pc_steps);
}
}
break;
*/
if (list_length(result) + list_length(pending) <= SyncRepConfig->num_sync)
{
- bool needfree = (result != NIL && pending != NIL);
-
/*
* Set *am_sync to true if this walsender is in the pending list
* because all pending standbys are considered as sync.
*am_sync = am_in_pending;
result = list_concat(result, pending);
- if (needfree)
- pfree(pending);
+ list_free(pending);
return result;
}
/* combine the two */
memcpy(fstore, prior_expr, sizeof(FieldStore));
fstore->newvals =
- list_concat(list_copy(((FieldStore *) prior_expr)->newvals),
- list_copy(((FieldStore *) src_expr)->newvals));
+ list_concat_copy(((FieldStore *) prior_expr)->newvals,
+ ((FieldStore *) src_expr)->newvals);
fstore->fieldnums =
- list_concat(list_copy(((FieldStore *) prior_expr)->fieldnums),
- list_copy(((FieldStore *) src_expr)->fieldnums));
+ list_concat_copy(((FieldStore *) prior_expr)->fieldnums,
+ ((FieldStore *) src_expr)->fieldnums);
}
else
{
RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
List *args = ((FuncExpr *) rtfunc->funcexpr)->args;
- allargs = list_concat(allargs, list_copy(args));
+ allargs = list_concat(allargs, args);
}
appendStringInfoString(buf, "UNNEST(");
if (!predicate_implied_by(oneQual, indexQuals, false))
predExtraQuals = list_concat(predExtraQuals, oneQual);
}
- /* list_concat avoids modifying the passed-in indexQuals list */
return list_concat(predExtraQuals, indexQuals);
}
extern List *lcons_oid(Oid datum, List *list);
extern List *list_concat(List *list1, const List *list2);
+extern List *list_concat_copy(const List *list1, const List *list2);
+
extern List *list_truncate(List *list, int new_size);
extern bool list_member(const List *list, const void *datum);
projects / postgresql.git / commitdiff