#include "postgres.h"
#include "nodes/pg_list.h"
#include "port/pg_bitutils.h"
#include "utils/memdebug.h"
#include "utils/memutils.h"

Include dependency graph for list.c:

Macros
#define	LIST_HEADER_OVERHEAD ((int) ((offsetof(List, initial_elements) - 1) / sizeof(ListCell) + 1))

#define	IsPointerList(l) ((l) == NIL \|\| IsA((l), List))

#define	IsIntegerList(l) ((l) == NIL \|\| IsA((l), IntList))

#define	IsOidList(l) ((l) == NIL \|\| IsA((l), OidList))

#define	IsXidList(l) ((l) == NIL \|\| IsA((l), XidList))

#define	check_list_invariants(l) ((void) 0)

Functions
static List *	new_list (NodeTag type, int min_size)

static void	enlarge_list (List *list, int min_size)

List *	list_make1_impl (NodeTag t, ListCell datum1)

List *	list_make2_impl (NodeTag t, ListCell datum1, ListCell datum2)

List *	list_make3_impl (NodeTag t, ListCell datum1, ListCell datum2, ListCell datum3)

List *	list_make4_impl (NodeTag t, ListCell datum1, ListCell datum2, ListCell datum3, ListCell datum4)

List *	list_make5_impl (NodeTag t, ListCell datum1, ListCell datum2, ListCell datum3, ListCell datum4, ListCell datum5)

static void	new_head_cell (List *list)

static void	new_tail_cell (List *list)

List *	lappend (List list, void datum)

List *	lappend_int (List *list, int datum)

List *	lappend_oid (List *list, Oid datum)

List *	lappend_xid (List *list, TransactionId datum)

static ListCell *	insert_new_cell (List *list, int pos)

List *	list_insert_nth (List list, int pos, void datum)

List *	list_insert_nth_int (List *list, int pos, int datum)

List *	list_insert_nth_oid (List *list, int pos, Oid datum)

List *	lcons (void datum, List list)

List *	lcons_int (int datum, List *list)

List *	lcons_oid (Oid datum, List *list)

List *	list_concat (List list1, const List list2)

List *	list_concat_copy (const List list1, const List list2)

List *	list_truncate (List *list, int new_size)

bool	list_member (const List list, const void datum)

bool	list_member_ptr (const List list, const void datum)

bool	list_member_int (const List *list, int datum)

bool	list_member_oid (const List *list, Oid datum)

bool	list_member_xid (const List *list, TransactionId datum)

List *	list_delete_nth_cell (List *list, int n)

List *	list_delete_cell (List list, ListCell cell)

List *	list_delete (List list, void datum)

List *	list_delete_ptr (List list, void datum)

List *	list_delete_int (List *list, int datum)

List *	list_delete_oid (List *list, Oid datum)

List *	list_delete_first (List *list)

List *	list_delete_last (List *list)

List *	list_delete_first_n (List *list, int n)

List *	list_union (const List list1, const List list2)

List *	list_union_ptr (const List list1, const List list2)

List *	list_union_int (const List list1, const List list2)

List *	list_union_oid (const List list1, const List list2)

List *	list_intersection (const List list1, const List list2)

List *	list_intersection_int (const List list1, const List list2)

List *	list_difference (const List list1, const List list2)

List *	list_difference_ptr (const List list1, const List list2)

List *	list_difference_int (const List list1, const List list2)

List *	list_difference_oid (const List list1, const List list2)

List *	list_append_unique (List list, void datum)

List *	list_append_unique_ptr (List list, void datum)

List *	list_append_unique_int (List *list, int datum)

List *	list_append_unique_oid (List *list, Oid datum)

List *	list_concat_unique (List list1, const List list2)

List *	list_concat_unique_ptr (List list1, const List list2)

List *	list_concat_unique_int (List list1, const List list2)

List *	list_concat_unique_oid (List list1, const List list2)

void	list_deduplicate_oid (List *list)

static void	list_free_private (List *list, bool deep)

void	list_free (List *list)

void	list_free_deep (List *list)

List *	list_copy (const List *oldlist)

List *	list_copy_head (const List *oldlist, int len)

List *	list_copy_tail (const List *oldlist, int nskip)

List *	list_copy_deep (const List *oldlist)

void	list_sort (List *list, list_sort_comparator cmp)

int	list_int_cmp (const ListCell p1, const ListCell p2)

int	list_oid_cmp (const ListCell p1, const ListCell p2)

Macro Definition Documentation

◆ check_list_invariants

#define check_list_invariants ( l ) ((void) 0)

Definition at line 79 of file list.c.

◆ IsIntegerList

#define IsIntegerList ( l ) ((l) == NIL || IsA((l), IntList))

Definition at line 55 of file list.c.

◆ IsOidList

#define IsOidList ( l ) ((l) == NIL || IsA((l), OidList))

Definition at line 56 of file list.c.

◆ IsPointerList

#define IsPointerList ( l ) ((l) == NIL || IsA((l), List))

Definition at line 54 of file list.c.

◆ IsXidList

#define IsXidList ( l ) ((l) == NIL || IsA((l), XidList))

Definition at line 57 of file list.c.

◆ LIST_HEADER_OVERHEAD

#define LIST_HEADER_OVERHEAD ((int) ((offsetof(List, initial_elements) - 1) / sizeof(ListCell) + 1))

Definition at line 47 of file list.c.

Function Documentation

◆ enlarge_list()

static void enlarge_list	(	List *	list,
		int	min_size
	)

static

Definition at line 154 of file list.c.

 {
     int         new_max_len;
  
     Assert(min_size > list->max_length);    /* else we shouldn't be here */
  
 #ifndef DEBUG_LIST_MEMORY_USAGE
  
     /*
      * As above, we prefer power-of-two total allocations; but here we need
      * not account for list header overhead.
      */
  
     /* clamp the minimum value to 16, a semi-arbitrary small power of 2 */
     new_max_len = pg_nextpower2_32(Max(16, min_size));
  
 #else
     /* As above, don't allocate anything extra */
     new_max_len = min_size;
 #endif
  
     if (list->elements == list->initial_elements)
     {
         /*
          * Replace original in-line allocation with a separate palloc block.
          * Ensure it is in the same memory context as the List header.  (The
          * previous List implementation did not offer any guarantees about
          * keeping all list cells in the same context, but it seems reasonable
          * to create such a guarantee now.)
          */
         list->elements = (ListCell *)
             MemoryContextAlloc(GetMemoryChunkContext(list),
                                new_max_len * sizeof(ListCell));
         memcpy(list->elements, list->initial_elements,
                list->length * sizeof(ListCell));
  
         /*
          * We must not move the list header, so it's unsafe to try to reclaim
          * the initial_elements[] space via repalloc.  In debugging builds,
          * however, we can clear that space and/or mark it inaccessible.
          * (wipe_mem includes VALGRIND_MAKE_MEM_NOACCESS.)
          */
 #ifdef CLOBBER_FREED_MEMORY
         wipe_mem(list->initial_elements,
                  list->max_length * sizeof(ListCell));
 #else
         VALGRIND_MAKE_MEM_NOACCESS(list->initial_elements,
                                    list->max_length * sizeof(ListCell));
 #endif
     }
     else
     {
 #ifndef DEBUG_LIST_MEMORY_USAGE
         /* Normally, let repalloc deal with enlargement */
         list->elements = (ListCell *) repalloc(list->elements,
                                                new_max_len * sizeof(ListCell));
 #else
         /*
          * repalloc() might enlarge the space in-place, which we don't want
          * for debugging purposes, so forcibly move the data somewhere else.
          */
         ListCell   *newelements;
  
         newelements = (ListCell *)
             MemoryContextAlloc(GetMemoryChunkContext(list),
                                new_max_len * sizeof(ListCell));
         memcpy(newelements, list->elements,
                list->length * sizeof(ListCell));
         pfree(list->elements);
         list->elements = newelements;
 #endif
     }
  
     list->max_length = new_max_len;
 }

References Assert(), GetMemoryChunkContext(), sort-test::list, Max, MemoryContextAlloc(), pfree(), pg_nextpower2_32(), repalloc(), and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by insert_new_cell(), list_concat(), new_head_cell(), and new_tail_cell().

◆ insert_new_cell()

static ListCell* insert_new_cell	(	List *	list,
		int	pos
	)

static

Definition at line 414 of file list.c.

 {
     Assert(pos >= 0 && pos <= list->length);
  
     /* Enlarge array if necessary */
     if (list->length >= list->max_length)
         enlarge_list(list, list->length + 1);
     /* Now shove the existing data over */
     if (pos < list->length)
         memmove(&list->elements[pos + 1], &list->elements[pos],
                 (list->length - pos) * sizeof(ListCell));
     list->length++;
  
     return &list->elements[pos];
 }

References Assert(), enlarge_list(), and sort-test::list.

Referenced by list_insert_nth(), list_insert_nth_int(), and list_insert_nth_oid().

◆ lappend()

List* lappend	(	List *	list,
		void *	datum
	)

Definition at line 338 of file list.c.

 {
     Assert(IsPointerList(list));
  
     if (list == NIL)
         list = new_list(T_List, 1);
     else
         new_tail_cell(list);
  
     llast(list) = datum;
     check_list_invariants(list);
     return list;
 }

References Assert(), check_list_invariants, IsPointerList, sort-test::list, llast, new_list(), new_tail_cell(), and NIL.

◆ lappend_int()

List* lappend_int	(	List *	list,
		int	datum
	)

Definition at line 356 of file list.c.

 {
     Assert(IsIntegerList(list));
  
     if (list == NIL)
         list = new_list(T_IntList, 1);
     else
         new_tail_cell(list);
  
     llast_int(list) = datum;
     check_list_invariants(list);
     return list;
 }

References Assert(), check_list_invariants, IsIntegerList, sort-test::list, llast_int, new_list(), new_tail_cell(), and NIL.

Referenced by add_merged_range_bounds(), addRangeTableEntryForCTE(), addRangeTableEntryForENR(), addRangeTableEntryForFunction(), addRangeTableEntryForSubquery(), adjust_inherited_attnums(), adjust_partition_colnos_using_map(), analyzeCTETargetList(), ATRewriteTable(), build_merged_partition_bounds(), build_subplan(), check_ungrouped_columns_walker(), checkInsertTargets(), convert_EXISTS_to_ANY(), CopyGetAttnums(), deparseAnalyzeSql(), deparseExplicitTargetList(), deparseTargetList(), ExecBuildAggTrans(), ExecBuildGroupingEqual(), ExecBuildParamSetEqual(), ExecInitExprRec(), ExecInitQual(), ExecInitSubscriptingRef(), expand_indexqual_rowcompare(), extract_update_targetlist_colnos(), extractRemainingColumns(), fetch_statentries_for_relation(), finalize_grouping_exprs_walker(), find_all_inheritors(), find_compatible_agg(), fix_expr_common(), gen_partprune_steps_internal(), generate_subquery_params(), grouping_planner(), list_append_unique_int(), list_concat_unique_int(), list_difference_int(), list_intersection_int(), list_union_int(), match_pathkeys_to_index(), merge_list_bounds(), nodeRead(), postgresBeginForeignInsert(), postgresPlanForeignModify(), rel_is_distinct_for(), remap_to_groupclause_idx(), reorder_grouping_sets(), rewriteSearchAndCycle(), set_plan_refs(), split_pathtarget_at_srfs(), SS_process_ctes(), TerminateOtherDBBackends(), transformDistinctOnClause(), transformFromClauseItem(), transformGroupClauseList(), transformRangeTableFunc(), transformSetOperationTree(), transformValuesClause(), and translate_sub_tlist().

◆ lappend_oid()

List* lappend_oid	(	List *	list,
		Oid	datum
	)

Definition at line 374 of file list.c.

 {
     Assert(IsOidList(list));
  
     if (list == NIL)
         list = new_list(T_OidList, 1);
     else
         new_tail_cell(list);
  
     llast_oid(list) = datum;
     check_list_invariants(list);
     return list;
 }

References Assert(), check_list_invariants, IsOidList, sort-test::list, llast_oid, new_list(), new_tail_cell(), and NIL.

Referenced by add_rte_to_flat_rtable(), addRangeTableEntryForCTE(), addRangeTableEntryForENR(), addRangeTableEntryForFunction(), addRangeTableEntryForSubquery(), AfterTriggerSetState(), AlterTableMoveAll(), analyzeCTETargetList(), apply_handle_truncate(), ApplyExtensionUpdates(), assign_collations_walker(), assign_param_for_placeholdervar(), assign_param_for_var(), assign_special_exec_param(), binary_upgrade_create_empty_extension(), check_functional_grouping(), CheckAttributeType(), CloneFkReferenced(), CloneFkReferencing(), compute_semijoin_info(), convert_EXISTS_to_ANY(), create_hashjoin_plan(), create_indexscan_plan(), CreateExtensionInternal(), CreateFunction(), DefineRelation(), do_autovacuum(), EventTriggerCommonSetup(), ExecAlterDefaultPrivilegesStmt(), ExecInitPartitionInfo(), ExecInsertIndexTuples(), ExecuteGrantStmt(), ExecuteTruncate(), ExecuteTruncateGuts(), expand_indexqual_rowcompare(), extract_query_dependencies_walker(), ExtractExtensionList(), find_all_inheritors(), find_inheritance_children_extended(), find_typed_table_dependencies(), fireRIRrules(), fix_expr_common(), generate_new_exec_param(), get_index_ref_constraints(), get_mergejoin_opfamilies(), get_partition_ancestors_worker(), get_steps_using_prefix_recurse(), GetAllTablesPublicationRelations(), GetAllTablesPublications(), getAutoExtensionsOfObject(), getOwnedSequences_internal(), GetParentedForeignKeyRefs(), GetPublicationSchemas(), GetPubPartitionOptionRelations(), GetRelationPublications(), getRelationsInNamespace(), GetSchemaPublicationRelations(), GetSchemaPublications(), heap_truncate_check_FKs(), heap_truncate_find_FKs(), index_concurrently_swap(), infer_arbiter_indexes(), inline_function(), interpret_function_parameter_list(), list_append_unique_oid(), list_concat_unique_oid(), list_difference_oid(), list_union_oid(), LockViewRecurse(), logicalrep_read_truncate(), make_row_comparison_op(), nodeRead(), objectNamesToOids(), objectsInSchemaToOids(), oid_array_to_list(), OpenTableList(), paraminfo_get_equal_hashops(), PreCommit_on_commit_actions(), query_to_oid_list(), recomputeNamespacePath(), ReindexMultipleTables(), ReindexPartitions(), ReindexRelationConcurrently(), rel_is_distinct_for(), relation_is_updatable(), RelationGetIndexList(), RelationGetStatExtList(), RememberConstraintForRebuilding(), RememberIndexForRebuilding(), RememberStatisticsForRebuilding(), remove_dbtablespaces(), replace_outer_agg(), replace_outer_grouping(), RestoreReindexState(), rewriteSearchAndCycle(), roleSpecsToIds(), transformAggregateCall(), transformRangeTableFunc(), transformSetOperationTree(), transformValuesClause(), TryReuseForeignKey(), and typeInheritsFrom().

◆ lappend_xid()

List* lappend_xid	(	List *	list,
		TransactionId	datum
	)

Definition at line 392 of file list.c.

 {
     Assert(IsXidList(list));
  
     if (list == NIL)
         list = new_list(T_XidList, 1);
     else
         new_tail_cell(list);
  
     llast_xid(list) = datum;
     check_list_invariants(list);
     return list;
 }

References Assert(), check_list_invariants, IsXidList, sort-test::list, llast_xid, new_list(), new_tail_cell(), and NIL.

Referenced by nodeRead(), pa_start_subtrans(), and set_schema_sent_in_streamed_txn().

◆ lcons()

List* lcons	(	void *	datum,
		List *	list
	)

Definition at line 494 of file list.c.

 {
     Assert(IsPointerList(list));
  
     if (list == NIL)
         list = new_list(T_List, 1);
     else
         new_head_cell(list);
  
     linitial(list) = datum;
     check_list_invariants(list);
     return list;
 }

References Assert(), check_list_invariants, IsPointerList, linitial, sort-test::list, new_head_cell(), new_list(), and NIL.

Referenced by build_minmax_path(), checkWellFormedRecursionWalker(), consider_groupingsets_paths(), CreateExprContextInternal(), CreateLockFile(), ExecInitModifyTable(), expandTableLikeClause(), ExplainNode(), ExplainSubPlans(), extract_rollup_sets(), find_expr_references_walker(), find_update_path(), generateSerialExtraStmts(), get_name_for_var_field(), get_object_address_rv(), get_query_def(), get_relation_info(), gistEmptyAllBuffers(), gistFindPath(), gistGetNodeBuffer(), gistPushItupToNodeBuffer(), load_domaintype_info(), makeDependencyGraphWalker(), pg_get_object_address(), plan_union_children(), PLy_subtransaction_enter(), PrepareClientEncoding(), push_child_plan(), pushOperator(), PushOverrideSearchPath(), pushStop(), pushValue_internal(), readTimeLineHistory(), register_on_commit_action(), RelationBuildRowSecurity(), RelationCacheInvalidate(), reorder_grouping_sets(), RewriteQuery(), rewriteSearchAndCycle(), rewriteTargetView(), sepgsql_avc_compute(), set_cheapest(), show_agg_keys(), show_group_keys(), sort_inner_and_outer(), and transformCaseExpr().

◆ lcons_int()

List* lcons_int	(	int	datum,
		List *	list
	)

Definition at line 512 of file list.c.

 {
     Assert(IsIntegerList(list));
  
     if (list == NIL)
         list = new_list(T_IntList, 1);
     else
         new_head_cell(list);
  
     linitial_int(list) = datum;
     check_list_invariants(list);
     return list;
 }

References Assert(), check_list_invariants, IsIntegerList, linitial_int, sort-test::list, new_head_cell(), new_list(), and NIL.

Referenced by ExecInitAgg(), ExplainBeginOutput(), ExplainOpenGroup(), ExplainOpenSetAsideGroup(), and ExplainRestoreGroup().

◆ lcons_oid()

List* lcons_oid	(	Oid	datum,
		List *	list
	)

Definition at line 530 of file list.c.

 {
     Assert(IsOidList(list));
  
     if (list == NIL)
         list = new_list(T_OidList, 1);
     else
         new_head_cell(list);
  
     linitial_oid(list) = datum;
     check_list_invariants(list);
     return list;
 }

References Assert(), check_list_invariants, IsOidList, linitial_oid, sort-test::list, new_head_cell(), new_list(), and NIL.

Referenced by pg_partition_ancestors(), PushOverrideSearchPath(), recomputeNamespacePath(), and ReindexMultipleTables().

◆ list_append_unique()

List* list_append_unique	(	List *	list,
		void *	datum
	)

Definition at line 1342 of file list.c.

 {
     if (list_member(list, datum))
         return list;
     else
         return lappend(list, datum);
 }

References lappend(), sort-test::list, and list_member().

Referenced by add_security_quals(), add_with_check_options(), check_publications_origin(), and create_index_paths().

◆ list_append_unique_int()

List* list_append_unique_int	(	List *	list,
		int	datum
	)

Definition at line 1367 of file list.c.

 {
     if (list_member_int(list, datum))
         return list;
     else
         return lappend_int(list, datum);
 }

References lappend_int(), sort-test::list, and list_member_int().

◆ list_append_unique_oid()

List* list_append_unique_oid	(	List *	list,
		Oid	datum
	)

Definition at line 1379 of file list.c.

 {
     if (list_member_oid(list, datum))
         return list;
     else
         return lappend_oid(list, datum);
 }

References lappend_oid(), sort-test::list, and list_member_oid().

Referenced by ATExecAlterConstrRecurse(), btvalidate(), hashvalidate(), heap_truncate_find_FKs(), LogicalRepWorkersWakeupAtCommit(), map_sql_typecoll_to_xmlschema_types(), ObjectsInPublicationToOids(), and roles_is_member_of().

◆ list_append_unique_ptr()

List* list_append_unique_ptr	(	List *	list,
		void *	datum
	)

Definition at line 1355 of file list.c.

 {
     if (list_member_ptr(list, datum))
         return list;
     else
         return lappend(list, datum);
 }

References lappend(), sort-test::list, and list_member_ptr().

Referenced by get_useful_ecs_for_relation(), postgresGetForeignPaths(), subbuild_joinrel_joinlist(), and subbuild_joinrel_restrictlist().

◆ list_concat()

List* list_concat	(	List *	list1,
		const List *	list2
	)

Definition at line 560 of file list.c.

 {
     int         new_len;
  
     if (list1 == NIL)
         return list_copy(list2);
     if (list2 == NIL)
         return list1;
  
     Assert(list1->type == list2->type);
  
     new_len = list1->length + list2->length;
     /* Enlarge array if necessary */
     if (new_len > list1->max_length)
         enlarge_list(list1, new_len);
  
     /* Even if list1 == list2, using memcpy should be safe here */
     memcpy(&list1->elements[list1->length], &list2->elements[0],
            list2->length * sizeof(ListCell));
     list1->length = new_len;
  
     check_list_invariants(list1);
     return list1;
 }

References Assert(), check_list_invariants, List::elements, enlarge_list(), List::length, list_copy(), List::max_length, NIL, and List::type.

Referenced by accumulate_append_subpath(), add_predicate_to_index_quals(), addRangeTableEntryForJoin(), addRangeTableEntryForTableFunc(), ATExecAttachPartition(), ATParseTransformCmd(), ATPostAlterTypeParse(), AtSubCommit_Notify(), build_joinrel_restrictlist(), build_paths_for_OR(), check_index_predicates(), choose_bitmap_and(), clean_up_removed_plan_level(), CombineRangeTables(), consider_groupingsets_paths(), ConstraintImpliedByRelConstraint(), cost_index(), create_append_path(), create_append_plan(), create_bitmap_subplan(), create_index_paths(), create_join_plan(), create_one_window_path(), deconstruct_distribute(), deconstruct_recurse(), DefineRelation(), deparseDirectDeleteSql(), deparseDirectUpdateSql(), deparseFromExprForRel(), estimate_path_cost_size(), expand_groupingset_node(), ExpandAllTables(), expandRTE(), extract_or_clause(), extract_rollup_sets(), fileBeginForeignScan(), fileGetOptions(), find_indexpath_quals(), find_mergeclauses_for_outer_pathkeys(), fireRIRrules(), flatten_grouping_sets(), foreign_grouping_ok(), foreign_join_ok(), gen_partprune_steps_internal(), gen_prune_steps_from_opexps(), generate_bitmap_or_paths(), generate_join_implied_equalities(), generate_join_implied_equalities_for_ecs(), generate_join_implied_equalities_normal(), generate_partition_qual(), get_baserel_parampathinfo(), get_batch_size_option(), get_foreign_key_join_selectivity(), get_from_clause_item(), get_index_paths(), get_join_index_paths(), get_joinrel_parampathinfo(), get_relation_constraints(), get_rels_with_domain(), get_steps_using_prefix_recurse(), GetAllSchemaPublicationRelations(), GetPubPartitionOptionRelations(), is_parallel_safe(), objectsInSchemaToOids(), optimize_window_clauses(), process_equivalence(), process_sublinks_mutator(), ProcessUtilitySlow(), pull_ands(), pull_ors(), pull_up_simple_subquery(), reduce_unique_semijoins(), remove_useless_results_recurse(), reorder_grouping_sets(), RewriteQuery(), rewriteRuleAction(), rewriteTargetListIU(), selectColorTrigrams(), set_joinrel_partition_key_exprs(), set_plan_refs(), split_pathtarget_at_srfs(), split_pathtarget_walker(), TidQualFromRestrictInfoList(), transformAExprIn(), transformAlterTableStmt(), transformCreateSchemaStmtElements(), transformCreateStmt(), transformExpressionList(), transformExtendedStatistics(), transformFromClause(), transformFromClauseItem(), transformIndexConstraints(), transformTargetList(), TS_execute_locations_recurse(), and vacuum().

◆ list_concat_copy()

List* list_concat_copy	(	const List *	list1,
		const List *	list2
	)

Definition at line 597 of file list.c.

 {
     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;
 }

References Assert(), check_list_invariants, List::elements, List::length, list_copy(), new_list(), NIL, and List::type.

Referenced by add_function_defaults(), btadjustmembers(), build_paths_for_OR(), choose_bitmap_and(), cost_subqueryscan(), create_scan_plan(), DefineIndex(), gen_partprune_steps(), generate_bitmap_or_paths(), get_parameterized_baserel_size(), hashadjustmembers(), make_pathkeys_for_window(), max_parallel_hazard_walker(), preprocess_targetlist(), process_matched_tle(), set_joinrel_partition_key_exprs(), simplify_and_arguments(), and simplify_or_arguments().

◆ list_concat_unique()

List* list_concat_unique	(	List *	list1,
		const List *	list2
	)

Definition at line 1404 of file list.c.

 {
     ListCell   *cell;
  
     Assert(IsPointerList(list1));
     Assert(IsPointerList(list2));
  
     foreach(cell, list2)
     {
         if (!list_member(list1, lfirst(cell)))
             list1 = lappend(list1, lfirst(cell));
     }
  
     check_list_invariants(list1);
     return list1;
 }

References Assert(), check_list_invariants, IsPointerList, lappend(), lfirst, and list_member().

Referenced by create_bitmap_subplan(), and select_active_windows().

◆ list_concat_unique_int()

List* list_concat_unique_int	(	List *	list1,
		const List *	list2
	)

Definition at line 1447 of file list.c.

 {
     ListCell   *cell;
  
     Assert(IsIntegerList(list1));
     Assert(IsIntegerList(list2));
  
     foreach(cell, list2)
     {
         if (!list_member_int(list1, lfirst_int(cell)))
             list1 = lappend_int(list1, lfirst_int(cell));
     }
  
     check_list_invariants(list1);
     return list1;
 }

References Assert(), check_list_invariants, IsIntegerList, lappend_int(), lfirst_int, and list_member_int().

◆ list_concat_unique_oid()

List* list_concat_unique_oid	(	List *	list1,
		const List *	list2
	)

Definition at line 1468 of file list.c.

 {
     ListCell   *cell;
  
     Assert(IsOidList(list1));
     Assert(IsOidList(list2));
  
     foreach(cell, list2)
     {
         if (!list_member_oid(list1, lfirst_oid(cell)))
             list1 = lappend_oid(list1, lfirst_oid(cell));
     }
  
     check_list_invariants(list1);
     return list1;
 }

References Assert(), check_list_invariants, IsOidList, lappend_oid(), lfirst_oid, and list_member_oid().

Referenced by AlterPublicationOptions(), GetSchemaPublicationRelations(), pg_get_publication_tables(), and RelationBuildPublicationDesc().

◆ list_concat_unique_ptr()

List* list_concat_unique_ptr	(	List *	list1,
		const List *	list2
	)

Definition at line 1426 of file list.c.

 {
     ListCell   *cell;
  
     Assert(IsPointerList(list1));
     Assert(IsPointerList(list2));
  
     foreach(cell, list2)
     {
         if (!list_member_ptr(list1, lfirst(cell)))
             list1 = lappend(list1, lfirst(cell));
     }
  
     check_list_invariants(list1);
     return list1;
 }

References Assert(), check_list_invariants, IsPointerList, lappend(), lfirst, and list_member_ptr().

◆ list_copy()

List* list_copy ( const List * oldlist )

Definition at line 1572 of file list.c.

 {
     List       *newlist;
  
     if (oldlist == NIL)
         return NIL;
  
     newlist = new_list(oldlist->type, oldlist->length);
     memcpy(newlist->elements, oldlist->elements,
            newlist->length * sizeof(ListCell));
  
     check_list_invariants(newlist);
     return newlist;
 }

References check_list_invariants, List::elements, List::length, new_list(), NIL, and List::type.

Referenced by addRangeTableEntryForCTE(), adjust_group_pathkeys_for_groupagg(), arrayconst_startup_fn(), arrayexpr_startup_fn(), build_subplan(), check_index_predicates(), check_publications(), consider_groupingsets_paths(), ConstraintImpliedByRelConstraint(), copy_pathtarget(), copyObjectImpl(), CopyOverrideSearchPath(), EventTriggerCollectGrant(), ExecuteTruncateGuts(), expression_tree_mutator_impl(), fetch_search_path(), generate_mergejoin_paths(), generateSerialExtraStmts(), get_eclass_for_sort_expr(), get_foreign_key_join_selectivity(), get_query_def(), get_required_extension(), get_steps_using_prefix_recurse(), get_switched_clauses(), get_useful_pathkeys_for_relation(), GetOverrideSearchPath(), heap_truncate_find_FKs(), list_concat(), list_concat_copy(), list_difference(), list_difference_int(), list_difference_oid(), list_difference_ptr(), list_union(), list_union_int(), list_union_oid(), list_union_ptr(), merge_publications(), preprocess_groupclause(), PushOverrideSearchPath(), recomputeNamespacePath(), RelationGetIndexList(), RelationGetStatExtList(), remove_rel_from_query(), reorder_grouping_sets(), roles_is_member_of(), select_active_windows(), select_outer_pathkeys_for_merge(), set_joinrel_partition_key_exprs(), set_using_names(), SetReindexPending(), simplify_and_arguments(), simplify_or_arguments(), sort_inner_and_outer(), standard_qp_callback(), transformPLAssignStmt(), and transformWithClause().

◆ list_copy_deep()

List* list_copy_deep ( const List * oldlist )

Definition at line 1638 of file list.c.

 {
     List       *newlist;
  
     if (oldlist == NIL)
         return NIL;
  
     /* This is only sensible for pointer Lists */
     Assert(IsA(oldlist, List));
  
     newlist = new_list(oldlist->type, oldlist->length);
     for (int i = 0; i < newlist->length; i++)
         lfirst(&newlist->elements[i]) =
             copyObjectImpl(lfirst(&oldlist->elements[i]));
  
     check_list_invariants(newlist);
     return newlist;
 }

References Assert(), check_list_invariants, copyObjectImpl(), List::elements, i, IsA, List::length, lfirst, new_list(), NIL, and List::type.

Referenced by copyObjectImpl().

◆ list_copy_head()

List* list_copy_head	(	const List *	oldlist,
		int	len
	)

Definition at line 1592 of file list.c.

 {
     List       *newlist;
  
     if (oldlist == NIL || len <= 0)
         return NIL;
  
     len = Min(oldlist->length, len);
  
     newlist = new_list(oldlist->type, len);
     memcpy(newlist->elements, oldlist->elements, len * sizeof(ListCell));
  
     check_list_invariants(newlist);
     return newlist;
 }

References check_list_invariants, List::elements, len, List::length, Min, new_list(), NIL, and List::type.

Referenced by accumulate_append_subpath(), create_append_plan(), create_merge_append_plan(), does_not_exist_skipping(), expand_indexqual_rowcompare(), get_object_address_attrdef(), get_object_address_attribute(), get_object_address_opf_member(), get_object_address_relobject(), get_useful_pathkeys_for_relation(), owningrel_does_not_exist_skipping(), process_owned_by(), select_outer_pathkeys_for_merge(), and truncate_useless_pathkeys().

◆ list_copy_tail()

List* list_copy_tail	(	const List *	oldlist,
		int	nskip
	)

Definition at line 1612 of file list.c.

 {
     List       *newlist;
  
     if (nskip < 0)
         nskip = 0;              /* would it be better to elog? */
  
     if (oldlist == NIL || nskip >= oldlist->length)
         return NIL;
  
     newlist = new_list(oldlist->type, oldlist->length - nskip);
     memcpy(newlist->elements, &oldlist->elements[nskip],
            newlist->length * sizeof(ListCell));
  
     check_list_invariants(newlist);
     return newlist;
 }

References check_list_invariants, List::elements, List::length, new_list(), NIL, and List::type.

Referenced by accumulate_append_subpath(), addRangeTableEntryForJoin(), addRangeTableEntryForTableFunc(), does_not_exist_skipping(), expandRTE(), get_name_for_var_field(), get_object_address_opcf(), ParseFuncOrColumn(), push_ancestor_plan(), and transformAggregateCall().

◆ list_deduplicate_oid()

void list_deduplicate_oid ( List * list )

Definition at line 1494 of file list.c.

 {
     int         len;
  
     Assert(IsOidList(list));
     len = list_length(list);
     if (len > 1)
     {
         ListCell   *elements = list->elements;
         int         i = 0;
  
         for (int j = 1; j < len; j++)
         {
             if (elements[i].oid_value != elements[j].oid_value)
                 elements[++i].oid_value = elements[j].oid_value;
         }
         list->length = i + 1;
     }
     check_list_invariants(list);
 }

References Assert(), check_list_invariants, i, IsOidList, j, len, sort-test::list, list_length(), and ListCell::oid_value.

Referenced by GetPublicationRelations(), and heap_truncate_find_FKs().

◆ list_delete()

List* list_delete	(	List *	list,
		void *	datum
	)

Definition at line 852 of file list.c.

 {
     ListCell   *cell;
  
     Assert(IsPointerList(list));
     check_list_invariants(list);
  
     foreach(cell, list)
     {
         if (equal(lfirst(cell), datum))
             return list_delete_cell(list, cell);
     }
  
     /* Didn't find a match: return the list unmodified */
     return list;
 }

References Assert(), check_list_invariants, equal(), IsPointerList, lfirst, sort-test::list, and list_delete_cell().

Referenced by check_publications(), postgresGetForeignPlan(), and unregister_ENR().

◆ list_delete_cell()

List* list_delete_cell	(	List *	list,
		ListCell *	cell
	)

Definition at line 840 of file list.c.

 {
     return list_delete_nth_cell(list, cell - list->elements);
 }

References sort-test::list, and list_delete_nth_cell().

Referenced by list_delete(), list_delete_int(), list_delete_oid(), list_delete_ptr(), remove_useless_joins(), and transformGenericOptions().

◆ list_delete_first()

List* list_delete_first ( List * list )

Definition at line 942 of file list.c.

 {
     check_list_invariants(list);
  
     if (list == NIL)
         return NIL;             /* would an error be better? */
  
     return list_delete_nth_cell(list, 0);
 }

References check_list_invariants, sort-test::list, list_delete_nth_cell(), and NIL.

Referenced by AtEOSubXact_Namespace(), AtEOXact_Namespace(), checkWellFormedRecursionWalker(), CopyMultiInsertInfoFlush(), ExplainCloseGroup(), ExplainEndOutput(), ExplainNode(), ExplainSaveGroup(), ExplainSubPlans(), fetch_search_path(), find_expr_references_walker(), get_name_for_var_field(), GetOverrideSearchPath(), gistEmptyAllBuffers(), gistFindPath(), gistProcessEmptyingQueue(), jsonb_path_query_internal(), makeDependencyGraphWalker(), plan_union_children(), PLy_abort_open_subtransactions(), PLy_subtransaction_exit(), pop_child_plan(), PopOverrideSearchPath(), ProcessUtilitySlow(), show_agg_keys(), show_group_keys(), simplify_and_arguments(), simplify_or_arguments(), transformPLAssignStmt(), and transformWithClause().

◆ list_delete_first_n()

List* list_delete_first_n	(	List *	list,
		int	n
	)

Definition at line 982 of file list.c.

 {
     check_list_invariants(list);
  
     /* No-op request? */
     if (n <= 0)
         return list;
  
     /* Delete whole list? */
     if (n >= list_length(list))
     {
         list_free(list);
         return NIL;
     }
  
     /*
      * Otherwise, we normally just collapse out the removed elements.  But for
      * debugging purposes, move the whole list contents someplace else.
      *
      * (Note that we *must* keep the contents in the same memory context.)
      */
 #ifndef DEBUG_LIST_MEMORY_USAGE
     memmove(&list->elements[0], &list->elements[n],
             (list->length - n) * sizeof(ListCell));
     list->length -= n;
 #else
     {
         ListCell   *newelems;
         int         newmaxlen = list->length - n;
  
         newelems = (ListCell *)
             MemoryContextAlloc(GetMemoryChunkContext(list),
                                newmaxlen * sizeof(ListCell));
         memcpy(newelems, &list->elements[n], newmaxlen * sizeof(ListCell));
         if (list->elements != list->initial_elements)
             pfree(list->elements);
         else
         {
             /*
              * As in enlarge_list(), clear the initial_elements[] space and/or
              * mark it inaccessible.
              */
 #ifdef CLOBBER_FREED_MEMORY
             wipe_mem(list->initial_elements,
                      list->max_length * sizeof(ListCell));
 #else
             VALGRIND_MAKE_MEM_NOACCESS(list->initial_elements,
                                        list->max_length * sizeof(ListCell));
 #endif
         }
         list->elements = newelems;
         list->max_length = newmaxlen;
         list->length = newmaxlen;
         check_list_invariants(list);
     }
 #endif
  
     return list;
 }

References check_list_invariants, GetMemoryChunkContext(), sort-test::list, list_free(), list_length(), MemoryContextAlloc(), NIL, pfree(), and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by add_function_defaults(), func_get_detail(), and SyncPostCheckpoint().

◆ list_delete_int()

List* list_delete_int	(	List *	list,
		int	datum
	)

Definition at line 890 of file list.c.

 {
     ListCell   *cell;
  
     Assert(IsIntegerList(list));
     check_list_invariants(list);
  
     foreach(cell, list)
     {
         if (lfirst_int(cell) == datum)
             return list_delete_cell(list, cell);
     }
  
     /* Didn't find a match: return the list unmodified */
     return list;
 }

References Assert(), check_list_invariants, IsIntegerList, lfirst_int, sort-test::list, and list_delete_cell().

Referenced by reorder_grouping_sets().

◆ list_delete_last()

List* list_delete_last ( List * list )

Definition at line 956 of file list.c.

 {
     check_list_invariants(list);
  
     if (list == NIL)
         return NIL;             /* would an error be better? */
  
     /* list_truncate won't free list if it goes to empty, but this should */
     if (list_length(list) <= 1)
     {
         list_free(list);
         return NIL;
     }
  
     return list_truncate(list, list_length(list) - 1);
 }

References check_list_invariants, sort-test::list, list_free(), list_length(), list_truncate(), and NIL.

Referenced by agg_refill_hash_table(), CheckAttributeType(), fireRIRrules(), inline_function(), LockViewRecurse(), relation_is_updatable(), RewriteQuery(), transformMultiAssignRef(), and transformOnConflictClause().

◆ list_delete_nth_cell()

List* list_delete_nth_cell	(	List *	list,
		int	n
	)

Definition at line 766 of file list.c.

 {
     check_list_invariants(list);
  
     Assert(n >= 0 && n < list->length);
  
     /*
      * If we're about to delete the last node from the list, free the whole
      * list instead and return NIL, which is the only valid representation of
      * a zero-length list.
      */
     if (list->length == 1)
     {
         list_free(list);
         return NIL;
     }
  
     /*
      * Otherwise, we normally just collapse out the removed element.  But for
      * debugging purposes, move the whole list contents someplace else.
      *
      * (Note that we *must* keep the contents in the same memory context.)
      */
 #ifndef DEBUG_LIST_MEMORY_USAGE
     memmove(&list->elements[n], &list->elements[n + 1],
             (list->length - 1 - n) * sizeof(ListCell));
     list->length--;
 #else
     {
         ListCell   *newelems;
         int         newmaxlen = list->length - 1;
  
         newelems = (ListCell *)
             MemoryContextAlloc(GetMemoryChunkContext(list),
                                newmaxlen * sizeof(ListCell));
         memcpy(newelems, list->elements, n * sizeof(ListCell));
         memcpy(&newelems[n], &list->elements[n + 1],
                (list->length - 1 - n) * sizeof(ListCell));
         if (list->elements != list->initial_elements)
             pfree(list->elements);
         else
         {
             /*
              * As in enlarge_list(), clear the initial_elements[] space and/or
              * mark it inaccessible.
              */
 #ifdef CLOBBER_FREED_MEMORY
             wipe_mem(list->initial_elements,
                      list->max_length * sizeof(ListCell));
 #else
             VALGRIND_MAKE_MEM_NOACCESS(list->initial_elements,
                                        list->max_length * sizeof(ListCell));
 #endif
         }
         list->elements = newelems;
         list->max_length = newmaxlen;
         list->length--;
         check_list_invariants(list);
     }
 #endif
  
     return list;
 }

References Assert(), check_list_invariants, GetMemoryChunkContext(), sort-test::list, list_free(), MemoryContextAlloc(), NIL, pfree(), and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by generateSerialExtraStmts(), list_delete_cell(), list_delete_first(), MergeAttributes(), process_equivalence(), reconsider_full_join_clause(), and sort_inner_and_outer().

◆ list_delete_oid()

List* list_delete_oid	(	List *	list,
		Oid	datum
	)

Definition at line 909 of file list.c.

 {
     ListCell   *cell;
  
     Assert(IsOidList(list));
     check_list_invariants(list);
  
     foreach(cell, list)
     {
         if (lfirst_oid(cell) == datum)
             return list_delete_cell(list, cell);
     }
  
     /* Didn't find a match: return the list unmodified */
     return list;
 }

References Assert(), check_list_invariants, IsOidList, lfirst_oid, sort-test::list, and list_delete_cell().

Referenced by RemoveReindexPending().

◆ list_delete_ptr()

List* list_delete_ptr	(	List *	list,
		void *	datum
	)

Definition at line 871 of file list.c.

 {
     ListCell   *cell;
  
     Assert(IsPointerList(list));
     check_list_invariants(list);
  
     foreach(cell, list)
     {
         if (lfirst(cell) == datum)
             return list_delete_cell(list, cell);
     }
  
     /* Didn't find a match: return the list unmodified */
     return list;
 }

References Assert(), check_list_invariants, IsPointerList, lfirst, sort-test::list, and list_delete_cell().

Referenced by FreeExprContext(), pa_free_worker_info(), and remove_join_clause_from_rels().

◆ list_difference()

List* list_difference	(	const List *	list1,
		const List *	list2
	)

Definition at line 1236 of file list.c.

 {
     const ListCell *cell;
     List       *result = NIL;
  
     Assert(IsPointerList(list1));
     Assert(IsPointerList(list2));
  
     if (list2 == NIL)
         return list_copy(list1);
  
     foreach(cell, list1)
     {
         if (!list_member(list2, lfirst(cell)))
             result = lappend(result, lfirst(cell));
     }
  
     check_list_invariants(result);
     return result;
 }

References Assert(), check_list_invariants, IsPointerList, lappend(), lfirst, list_copy(), list_member(), and NIL.

Referenced by create_hashjoin_plan(), create_mergejoin_plan(), create_tidscan_plan(), infer_arbiter_indexes(), and process_duplicate_ors().

◆ list_difference_int()

List* list_difference_int	(	const List *	list1,
		const List *	list2
	)

Definition at line 1287 of file list.c.

 {
     const ListCell *cell;
     List       *result = NIL;
  
     Assert(IsIntegerList(list1));
     Assert(IsIntegerList(list2));
  
     if (list2 == NIL)
         return list_copy(list1);
  
     foreach(cell, list1)
     {
         if (!list_member_int(list2, lfirst_int(cell)))
             result = lappend_int(result, lfirst_int(cell));
     }
  
     check_list_invariants(result);
     return result;
 }

References Assert(), check_list_invariants, IsIntegerList, lappend_int(), lfirst_int, list_copy(), list_member_int(), and NIL.

Referenced by reorder_grouping_sets().

◆ list_difference_oid()

List* list_difference_oid	(	const List *	list1,
		const List *	list2
	)

Definition at line 1312 of file list.c.

 {
     const ListCell *cell;
     List       *result = NIL;
  
     Assert(IsOidList(list1));
     Assert(IsOidList(list2));
  
     if (list2 == NIL)
         return list_copy(list1);
  
     foreach(cell, list1)
     {
         if (!list_member_oid(list2, lfirst_oid(cell)))
             result = lappend_oid(result, lfirst_oid(cell));
     }
  
     check_list_invariants(result);
     return result;
 }

References Assert(), check_list_invariants, IsOidList, lappend_oid(), lfirst_oid, list_copy(), list_member_oid(), and NIL.

Referenced by AlterPublicationSchemas().

◆ list_difference_ptr()

List* list_difference_ptr	(	const List *	list1,
		const List *	list2
	)

Definition at line 1262 of file list.c.

 {
     const ListCell *cell;
     List       *result = NIL;
  
     Assert(IsPointerList(list1));
     Assert(IsPointerList(list2));
  
     if (list2 == NIL)
         return list_copy(list1);
  
     foreach(cell, list1)
     {
         if (!list_member_ptr(list2, lfirst(cell)))
             result = lappend(result, lfirst(cell));
     }
  
     check_list_invariants(result);
     return result;
 }

References Assert(), check_list_invariants, IsPointerList, lappend(), lfirst, list_copy(), list_member_ptr(), and NIL.

Referenced by create_bitmap_scan_plan(), and ExecuteTruncateGuts().

◆ list_free()

void list_free ( List * list )

Definition at line 1545 of file list.c.

 {
     list_free_private(list, false);
 }

References sort-test::list, and list_free_private().

Referenced by AfterTriggerSetState(), AlterIndexNamespaces(), arrayconst_cleanup_fn(), arrayexpr_cleanup_fn(), ATCheckPartitionsNotInUse(), AtEOSubXact_Namespace(), AtEOXact_Namespace(), ATExecChangeOwner(), ATExecDropNotNull(), ATExecSetTableSpace(), build_base_rel_tlists(), build_remote_returning(), BuildRelationExtStatistics(), calc_joinrel_size_estimate(), calculate_indexes_size(), calculate_toast_table_size(), check_createrole_self_grant(), check_datestyle(), check_io_direct(), check_log_destination(), check_search_path(), check_temp_tablespaces(), check_wal_consistency_checking(), choose_bitmap_and(), compute_semi_anti_join_factors(), CopyFrom(), CopyMultiInsertBufferFlush(), CopyMultiInsertInfoCleanup(), CreateExtensionInternal(), CreateTriggerFiringOn(), current_schema(), current_schemas(), DefineIndex(), DefineRelation(), distribute_qual_to_rels(), do_analyze_rel(), DropSubscription(), EventTriggerDDLCommandEnd(), EventTriggerDDLCommandStart(), EventTriggerSQLDrop(), EventTriggerTableRewrite(), ExecInitPartitionInfo(), ExecInsert(), ExecOpenIndices(), ExecPendingInserts(), ExecRefreshMatView(), ExecResetTupleTable(), ExecSimpleRelationInsert(), ExecSimpleRelationUpdate(), ExecUpdateEpilogue(), extract_lateral_references(), ExtractExtensionList(), find_all_inheritors(), find_compatible_agg(), find_computable_ec_member(), find_hash_columns(), find_placeholders_in_expr(), fix_placeholder_input_needed_levels(), generate_base_implied_equalities_no_const(), generate_partitionwise_join_paths(), get_rel_sync_entry(), get_relation_info(), get_relation_statistics(), get_steps_using_prefix_recurse(), GetTopMostAncestorInPublication(), heap_truncate_find_FKs(), index_concurrently_swap(), index_get_partition(), index_unchanged_by_update(), infer_arbiter_indexes(), list_delete_first_n(), list_delete_last(), list_delete_nth_cell(), llvm_release_context(), make_group_input_target(), make_partial_grouping_target(), make_pathkeys_for_window(), make_sort_input_target(), make_window_input_target(), max_parallel_hazard_walker(), merge_list_bounds(), merge_range_bounds(), ObjectsInPublicationToOids(), OpenTableList(), paraminfo_get_equal_hashops(), parse_hba_auth_opt(), pg_partition_root(), plpgsql_extra_checks_check_hook(), pop_ancestor_plan(), PopOverrideSearchPath(), PostmasterMain(), PrepareTempTablespaces(), preprocess_targetlist(), process_implied_equality(), processState(), ProcessUtilitySlow(), qual_is_pushdown_safe(), recomputeNamespacePath(), refresh_by_match_merge(), RelationCacheInvalidate(), RelationDestroyRelation(), RelationGetIndexAttrBitmap(), RelationGetIndexList(), RelationGetPrimaryKeyIndex(), RelationGetReplicaIndex(), RelationGetStatExtList(), relationHasPrimaryKey(), remove_dbtablespaces(), reorder_grouping_sets(), reparameterize_pathlist_by_child(), roles_is_member_of(), sepgsql_dml_privileges(), simplify_and_arguments(), simplify_or_arguments(), statext_mcv_clauselist_selectivity(), stringToQualifiedNameList(), textToQualifiedNameList(), toast_open_indexes(), transformFkeyCheckAttrs(), transformFkeyGetPrimaryKey(), transformTableLikeClause(), transformValuesClause(), triggered_change_notification(), typeInheritsFrom(), vac_open_indexes(), and WaitForLockers().

◆ list_free_deep()

void list_free_deep ( List * list )

Definition at line 1559 of file list.c.

 {
     /*
      * A "deep" free operation only makes sense on a list of pointers.
      */
     Assert(IsPointerList(list));
     list_free_private(list, true);
 }

References Assert(), IsPointerList, sort-test::list, and list_free_private().

Referenced by AfterTriggerFreeQuery(), checkSharedDependencies(), CloseTableList(), copy_table(), CreateDatabaseUsingWalLog(), deconstruct_jointree(), DetachPartitionFinalize(), Exec_UnlistenAllCommit(), fetch_remote_table_info(), FetchTableStates(), FreeSubscription(), get_rel_sync_entry(), gettype(), gistbufferinginserttuples(), hashagg_reset_spill_state(), load_libraries(), lookup_proof_cache(), pgoutput_row_filter_init(), PostmasterMain(), RelationDestroyRelation(), RelationGetFKeyList(), rescanLatestTimeLine(), StartReplication(), SyncPostCheckpoint(), verify_heapam(), WaitForLockersMultiple(), XLogReadDetermineTimeline(), and XLogSendPhysical().

◆ list_free_private()

static void list_free_private	(	List *	list,
		bool	deep
	)

static

Definition at line 1519 of file list.c.

 {
     if (list == NIL)
         return;                 /* nothing to do */
  
     check_list_invariants(list);
  
     if (deep)
     {
         for (int i = 0; i < list->length; i++)
             pfree(lfirst(&list->elements[i]));
     }
     if (list->elements != list->initial_elements)
         pfree(list->elements);
     pfree(list);
 }

References check_list_invariants, i, lfirst, sort-test::list, NIL, and pfree().

Referenced by list_free(), and list_free_deep().

◆ list_insert_nth()

List* list_insert_nth	(	List *	list,
		int	pos,
		void *	datum
	)

Definition at line 438 of file list.c.

 {
     if (list == NIL)
     {
         Assert(pos == 0);
         return list_make1(datum);
     }
     Assert(IsPointerList(list));
     lfirst(insert_new_cell(list, pos)) = datum;
     check_list_invariants(list);
     return list;
 }

References Assert(), check_list_invariants, insert_new_cell(), IsPointerList, lfirst, sort-test::list, list_make1, and NIL.

Referenced by add_partial_path(), add_path(), and merge_clump().

◆ list_insert_nth_int()

List* list_insert_nth_int	(	List *	list,
		int	pos,
		int	datum
	)

Definition at line 452 of file list.c.

 {
     if (list == NIL)
     {
         Assert(pos == 0);
         return list_make1_int(datum);
     }
     Assert(IsIntegerList(list));
     lfirst_int(insert_new_cell(list, pos)) = datum;
     check_list_invariants(list);
     return list;
 }

References Assert(), check_list_invariants, insert_new_cell(), IsIntegerList, lfirst_int, sort-test::list, list_make1_int, and NIL.

◆ list_insert_nth_oid()

List* list_insert_nth_oid	(	List *	list,
		int	pos,
		Oid	datum
	)

Definition at line 466 of file list.c.

 {
     if (list == NIL)
     {
         Assert(pos == 0);
         return list_make1_oid(datum);
     }
     Assert(IsOidList(list));
     lfirst_oid(insert_new_cell(list, pos)) = datum;
     check_list_invariants(list);
     return list;
 }

References Assert(), check_list_invariants, insert_new_cell(), IsOidList, lfirst_oid, sort-test::list, list_make1_oid, and NIL.

◆ list_int_cmp()

int list_int_cmp	(	const ListCell *	p1,
		const ListCell *	p2
	)

Definition at line 1690 of file list.c.

 {
     int         v1 = lfirst_int(p1);
     int         v2 = lfirst_int(p2);
  
     if (v1 < v2)
         return -1;
     if (v1 > v2)
         return 1;
     return 0;
 }

References lfirst_int, and p2.

Referenced by expand_grouping_sets().

◆ list_intersection()

List* list_intersection	(	const List *	list1,
		const List *	list2
	)

Definition at line 1173 of file list.c.

 {
     List       *result;
     const ListCell *cell;
  
     if (list1 == NIL || list2 == NIL)
         return NIL;
  
     Assert(IsPointerList(list1));
     Assert(IsPointerList(list2));
  
     result = NIL;
     foreach(cell, list1)
     {
         if (list_member(list2, lfirst(cell)))
             result = lappend(result, lfirst(cell));
     }
  
     check_list_invariants(result);
     return result;
 }

References Assert(), check_list_invariants, IsPointerList, lappend(), lfirst, list_member(), and NIL.

◆ list_intersection_int()

List* list_intersection_int	(	const List *	list1,
		const List *	list2
	)

Definition at line 1199 of file list.c.

 {
     List       *result;
     const ListCell *cell;
  
     if (list1 == NIL || list2 == NIL)
         return NIL;
  
     Assert(IsIntegerList(list1));
     Assert(IsIntegerList(list2));
  
     result = NIL;
     foreach(cell, list1)
     {
         if (list_member_int(list2, lfirst_int(cell)))
             result = lappend_int(result, lfirst_int(cell));
     }
  
     check_list_invariants(result);
     return result;
 }

References Assert(), check_list_invariants, IsIntegerList, lappend_int(), lfirst_int, list_member_int(), and NIL.

Referenced by parseCheckAggregates().

◆ list_make1_impl()

List* list_make1_impl	(	NodeTag	t,
		ListCell	datum1
	)

Definition at line 235 of file list.c.

 {
     List       *list = new_list(t, 1);
  
     list->elements[0] = datum1;
     check_list_invariants(list);
     return list;
 }

References check_list_invariants, sort-test::list, and new_list().

◆ list_make2_impl()

List* list_make2_impl	(	NodeTag	t,
		ListCell	datum1,
		ListCell	datum2
	)

Definition at line 245 of file list.c.

 {
     List       *list = new_list(t, 2);
  
     list->elements[0] = datum1;
     list->elements[1] = datum2;
     check_list_invariants(list);
     return list;
 }

References check_list_invariants, sort-test::list, and new_list().

◆ list_make3_impl()

List* list_make3_impl	(	NodeTag	t,
		ListCell	datum1,
		ListCell	datum2,
		ListCell	datum3
	)

Definition at line 256 of file list.c.

 {
     List       *list = new_list(t, 3);
  
     list->elements[0] = datum1;
     list->elements[1] = datum2;
     list->elements[2] = datum3;
     check_list_invariants(list);
     return list;
 }

References check_list_invariants, sort-test::list, and new_list().

◆ list_make4_impl()

List* list_make4_impl	(	NodeTag	t,
		ListCell	datum1,
		ListCell	datum2,
		ListCell	datum3,
		ListCell	datum4
	)

Definition at line 269 of file list.c.

 {
     List       *list = new_list(t, 4);
  
     list->elements[0] = datum1;
     list->elements[1] = datum2;
     list->elements[2] = datum3;
     list->elements[3] = datum4;
     check_list_invariants(list);
     return list;
 }

References check_list_invariants, sort-test::list, and new_list().

◆ list_make5_impl()

List* list_make5_impl	(	NodeTag	t,
		ListCell	datum1,
		ListCell	datum2,
		ListCell	datum3,
		ListCell	datum4,
		ListCell	datum5
	)

Definition at line 283 of file list.c.

 {
     List       *list = new_list(t, 5);
  
     list->elements[0] = datum1;
     list->elements[1] = datum2;
     list->elements[2] = datum3;
     list->elements[3] = datum4;
     list->elements[4] = datum5;
     check_list_invariants(list);
     return list;
 }

References check_list_invariants, sort-test::list, and new_list().

◆ list_member()

bool list_member	(	const List *	list,
		const void *	datum
	)

Definition at line 660 of file list.c.

 {
     const ListCell *cell;
  
     Assert(IsPointerList(list));
     check_list_invariants(list);
  
     foreach(cell, list)
     {
         if (equal(lfirst(cell), datum))
             return true;
     }
  
     return false;
 }

References Assert(), check_list_invariants, equal(), IsPointerList, lfirst, and sort-test::list.

Referenced by add_new_column_to_pathtarget(), analyzeCTE(), build_minmax_path(), consider_index_join_outer_rels(), create_bitmap_scan_plan(), ec_member_matches_foreign(), fetch_table_list(), find_window_functions_walker(), get_join_index_paths(), group_by_has_partkey(), infer_arbiter_indexes(), list_append_unique(), list_concat_unique(), list_difference(), list_intersection(), list_union(), process_duplicate_ors(), split_pathtarget_at_srfs(), and split_pathtarget_walker().

◆ list_member_int()

bool list_member_int	(	const List *	list,
		int	datum
	)

Definition at line 701 of file list.c.

 {
     const ListCell *cell;
  
     Assert(IsIntegerList(list));
     check_list_invariants(list);
  
     foreach(cell, list)
     {
         if (lfirst_int(cell) == datum)
             return true;
     }
  
     return false;
 }

References Assert(), check_list_invariants, IsIntegerList, lfirst_int, and sort-test::list.

Referenced by BeginCopyFrom(), BeginCopyTo(), check_ungrouped_columns_walker(), contain_exec_param_walker(), CopyGetAttnums(), estimate_num_groups(), ExecRelationIsTargetRelation(), init_returning_filter(), list_append_unique_int(), list_concat_unique_int(), list_difference_int(), list_intersection_int(), list_union_int(), max_parallel_hazard_walker(), parseCheckAggregates(), reorder_grouping_sets(), and transformDistinctOnClause().

◆ list_member_oid()

bool list_member_oid	(	const List *	list,
		Oid	datum
	)

Definition at line 721 of file list.c.

 {
     const ListCell *cell;
  
     Assert(IsOidList(list));
     check_list_invariants(list);
  
     foreach(cell, list)
     {
         if (lfirst_oid(cell) == datum)
             return true;
     }
  
     return false;
 }

References Assert(), check_list_invariants, IsOidList, lfirst_oid, and sort-test::list.

Referenced by AfterTriggerSaveEvent(), AlterTableMoveAll(), apply_handle_truncate(), ATExecAddInherit(), ATExecAttachPartition(), BeginCopyTo(), CheckAttributeType(), CloneFkReferenced(), CloneFkReferencing(), CollationIsVisible(), ConversionIsVisible(), DefineRelation(), ec_member_matches_indexcol(), ExecAlterObjectDependsStmt(), ExecCheckIndexConstraints(), ExecInitPartitionInfo(), ExecInsertIndexTuples(), ExecuteTruncate(), fireRIRrules(), FunctionIsVisible(), get_rel_sync_entry(), get_transform_fromsql(), get_transform_tosql(), GetTopMostAncestorInPublication(), has_privs_of_role(), hashvalidate(), have_partkey_equi_join(), heap_truncate_check_FKs(), heap_truncate_find_FKs(), inline_function(), is_member_of_role(), is_member_of_role_nosuper(), list_append_unique_oid(), list_concat_unique_oid(), list_difference_oid(), list_union_oid(), LockViewRecurse_walker(), lookup_shippable(), member_can_set_role(), OpclassIsVisible(), OpenTableList(), OperatorIsVisible(), OpfamilyIsVisible(), PlanCacheRelCallback(), recomputeNamespacePath(), ReindexIsProcessingIndex(), relation_has_unique_index_for(), relation_is_updatable(), RelationIsVisible(), RememberConstraintForRebuilding(), RememberIndexForRebuilding(), RememberStatisticsForRebuilding(), StatisticsObjIsVisible(), TSConfigIsVisible(), TSDictionaryIsVisible(), TSParserIsVisible(), TSTemplateIsVisible(), typeInheritsFrom(), and TypeIsVisible().

◆ list_member_ptr()

bool list_member_ptr	(	const List *	list,
		const void *	datum
	)

Definition at line 681 of file list.c.

 {
     const ListCell *cell;
  
     Assert(IsPointerList(list));
     check_list_invariants(list);
  
     foreach(cell, list)
     {
         if (lfirst(cell) == datum)
             return true;
     }
  
     return false;
 }

References Assert(), check_list_invariants, IsPointerList, lfirst, and sort-test::list.

Referenced by create_bitmap_scan_plan(), create_tidrangescan_plan(), create_tidscan_plan(), ExecInsert(), get_foreign_key_join_selectivity(), list_append_unique_ptr(), list_concat_unique_ptr(), list_difference_ptr(), list_union_ptr(), postgresGetForeignPlan(), preprocess_groupclause(), and remove_join_clause_from_rels().

◆ list_member_xid()

bool list_member_xid	(	const List *	list,
		TransactionId	datum
	)

Definition at line 741 of file list.c.

 {
     const ListCell *cell;
  
     Assert(IsXidList(list));
     check_list_invariants(list);
  
     foreach(cell, list)
     {
         if (lfirst_xid(cell) == datum)
             return true;
     }
  
     return false;
 }

References Assert(), check_list_invariants, IsXidList, lfirst_xid, and sort-test::list.

Referenced by get_schema_sent_in_streamed_txn(), and pa_start_subtrans().

◆ list_oid_cmp()

int list_oid_cmp	(	const ListCell *	p1,
		const ListCell *	p2
	)

Definition at line 1706 of file list.c.

 {
     Oid         v1 = lfirst_oid(p1);
     Oid         v2 = lfirst_oid(p2);
  
     if (v1 < v2)
         return -1;
     if (v1 > v2)
         return 1;
     return 0;
 }

References lfirst_oid, and p2.

Referenced by GetPublicationRelations(), heap_truncate_find_FKs(), RelationGetIndexList(), and RelationGetStatExtList().

◆ list_sort()

void list_sort	(	List *	list,
		list_sort_comparator	cmp
	)

Definition at line 1673 of file list.c.

 {
     typedef int (*qsort_comparator) (const void *a, const void *b);
     int         len;
  
     check_list_invariants(list);
  
     /* Nothing to do if there's less than two elements */
     len = list_length(list);
     if (len > 1)
         qsort(list->elements, len, sizeof(ListCell), (qsort_comparator) cmp);
 }

References a, b, check_list_invariants, cmp(), len, sort-test::list, list_length(), and qsort.

Referenced by create_append_path(), expand_grouping_sets(), GetPublicationRelations(), heap_truncate_find_FKs(), perform_base_backup(), RelationGetIndexList(), RelationGetStatExtList(), sort_policies_by_name(), and UpdateLogicalMappings().

◆ list_truncate()

List* list_truncate	(	List *	list,
		int	new_size
	)

Definition at line 630 of file list.c.

 {
     if (new_size <= 0)
         return NIL;             /* truncate to zero length */
  
     /* If asked to effectively extend the list, do nothing */
     if (new_size < list_length(list))
         list->length = new_size;
  
     /*
      * Note: unlike the individual-list-cell deletion functions, we don't move
      * the list cells to new storage, even in DEBUG_LIST_MEMORY_USAGE mode.
      * This is because none of them can move in this operation, so just like
      * in the old cons-cell-based implementation, this function doesn't
      * invalidate any pointers to cells of the list.  This is also the reason
      * for not wiping the memory of the deleted cells: the old code didn't
      * free them either.  Perhaps later we'll tighten this up.
      */
  
     return list;
 }

References sort-test::list, list_length(), and NIL.

Referenced by choose_bitmap_and(), expand_indexqual_rowcompare(), ExpandIndirectionStar(), expandRTE(), generate_mergejoin_paths(), geqo_eval(), list_delete_last(), mbms_int_members(), pa_stream_abort(), ParseFuncOrColumn(), transformAggregateCall(), transformFromClauseItem(), transformSetOperationStmt(), and transformWholeRowRef().

◆ list_union()

List* list_union	(	const List *	list1,
		const List *	list2
	)

Definition at line 1065 of file list.c.

 {
     List       *result;
     const ListCell *cell;
  
     Assert(IsPointerList(list1));
     Assert(IsPointerList(list2));
  
     result = list_copy(list1);
     foreach(cell, list2)
     {
         if (!list_member(result, lfirst(cell)))
             result = lappend(result, lfirst(cell));
     }
  
     check_list_invariants(result);
     return result;
 }

References Assert(), check_list_invariants, IsPointerList, lappend(), lfirst, list_copy(), and list_member().

Referenced by AddRelationNewConstraints(), and process_duplicate_ors().

◆ list_union_int()

List* list_union_int	(	const List *	list1,
		const List *	list2
	)

Definition at line 1112 of file list.c.

 {
     List       *result;
     const ListCell *cell;
  
     Assert(IsIntegerList(list1));
     Assert(IsIntegerList(list2));
  
     result = list_copy(list1);
     foreach(cell, list2)
     {
         if (!list_member_int(result, lfirst_int(cell)))
             result = lappend_int(result, lfirst_int(cell));
     }
  
     check_list_invariants(result);
     return result;
 }

References Assert(), check_list_invariants, IsIntegerList, lappend_int(), lfirst_int, list_copy(), and list_member_int().

Referenced by expand_grouping_sets().

◆ list_union_oid()

List* list_union_oid	(	const List *	list1,
		const List *	list2
	)

Definition at line 1135 of file list.c.

 {
     List       *result;
     const ListCell *cell;
  
     Assert(IsOidList(list1));
     Assert(IsOidList(list2));
  
     result = list_copy(list1);
     foreach(cell, list2)
     {
         if (!list_member_oid(result, lfirst_oid(cell)))
             result = lappend_oid(result, lfirst_oid(cell));
     }
  
     check_list_invariants(result);
     return result;
 }

References Assert(), check_list_invariants, IsOidList, lappend_oid(), lfirst_oid, list_copy(), and list_member_oid().

◆ list_union_ptr()

List* list_union_ptr	(	const List *	list1,
		const List *	list2
	)

Definition at line 1089 of file list.c.

 {
     List       *result;
     const ListCell *cell;
  
     Assert(IsPointerList(list1));
     Assert(IsPointerList(list2));
  
     result = list_copy(list1);
     foreach(cell, list2)
     {
         if (!list_member_ptr(result, lfirst(cell)))
             result = lappend(result, lfirst(cell));
     }
  
     check_list_invariants(result);
     return result;
 }

References Assert(), check_list_invariants, IsPointerList, lappend(), lfirst, list_copy(), and list_member_ptr().

◆ new_head_cell()

static void new_head_cell ( List * list )

static

Definition at line 304 of file list.c.

 {
     /* Enlarge array if necessary */
     if (list->length >= list->max_length)
         enlarge_list(list, list->length + 1);
     /* Now shove the existing data over */
     memmove(&list->elements[1], &list->elements[0],
             list->length * sizeof(ListCell));
     list->length++;
 }

References enlarge_list(), and sort-test::list.

Referenced by lcons(), lcons_int(), and lcons_oid().

◆ new_list()

static List* new_list	(	NodeTag	type,
		int	min_size
	)

static

Definition at line 90 of file list.c.

 {
     List       *newlist;
     int         max_size;
  
     Assert(min_size > 0);
  
     /*
      * We allocate all the requested cells, and possibly some more, as part of
      * the same palloc request as the List header.  This is a big win for the
      * typical case of short fixed-length lists.  It can lose if we allocate a
      * moderately long list and then it gets extended; we'll be wasting more
      * initial_elements[] space than if we'd made the header small.  However,
      * rounding up the request as we do in the normal code path provides some
      * defense against small extensions.
      */
  
 #ifndef DEBUG_LIST_MEMORY_USAGE
  
     /*
      * Normally, we set up a list with some extra cells, to allow it to grow
      * without a repalloc.  Prefer cell counts chosen to make the total
      * allocation a power-of-2, since palloc would round it up to that anyway.
      * (That stops being true for very large allocations, but very long lists
      * are infrequent, so it doesn't seem worth special logic for such cases.)
      *
      * The minimum allocation is 8 ListCell units, providing either 4 or 5
      * available ListCells depending on the machine's word width.  Counting
      * palloc's overhead, this uses the same amount of space as a one-cell
      * list did in the old implementation, and less space for any longer list.
      *
      * We needn't worry about integer overflow; no caller passes min_size
      * that's more than twice the size of an existing list, so the size limits
      * within palloc will ensure that we don't overflow here.
      */
     max_size = pg_nextpower2_32(Max(8, min_size + LIST_HEADER_OVERHEAD));
     max_size -= LIST_HEADER_OVERHEAD;
 #else
  
     /*
      * For debugging, don't allow any extra space.  This forces any cell
      * addition to go through enlarge_list() and thus move the existing data.
      */
     max_size = min_size;
 #endif
  
     newlist = (List *) palloc(offsetof(List, initial_elements) +
                               max_size * sizeof(ListCell));
     newlist->type = type;
     newlist->length = min_size;
     newlist->max_length = max_size;
     newlist->elements = newlist->initial_elements;
  
     return newlist;
 }

References Assert(), List::elements, List::initial_elements, List::length, LIST_HEADER_OVERHEAD, Max, List::max_length, palloc(), pg_nextpower2_32(), generate_unaccent_rules::type, and List::type.

Referenced by lappend(), lappend_int(), lappend_oid(), lappend_xid(), lcons(), lcons_int(), lcons_oid(), list_concat_copy(), list_copy(), list_copy_deep(), list_copy_head(), list_copy_tail(), list_make1_impl(), list_make2_impl(), list_make3_impl(), list_make4_impl(), list_make5_impl(), pg_parse_query(), and pg_rewrite_query().

◆ new_tail_cell()

static void new_tail_cell ( List * list )

static

Definition at line 322 of file list.c.

 {
     /* Enlarge array if necessary */
     if (list->length >= list->max_length)
         enlarge_list(list, list->length + 1);
     list->length++;
 }

References enlarge_list(), and sort-test::list.

Referenced by lappend(), lappend_int(), lappend_oid(), and lappend_xid().

Macros

Functions

Macro Definition Documentation

◆ check_list_invariants

◆ IsIntegerList

◆ IsOidList

◆ IsPointerList

◆ IsXidList

◆ LIST_HEADER_OVERHEAD

Function Documentation

◆ enlarge_list()

◆ insert_new_cell()

◆ lappend()

◆ lappend_int()

◆ lappend_oid()

◆ lappend_xid()

◆ lcons()

◆ lcons_int()

◆ lcons_oid()

◆ list_append_unique()

◆ list_append_unique_int()

◆ list_append_unique_oid()

◆ list_append_unique_ptr()

◆ list_concat()

◆ list_concat_copy()

◆ list_concat_unique()

◆ list_concat_unique_int()

◆ list_concat_unique_oid()

◆ list_concat_unique_ptr()

◆ list_copy()

◆ list_copy_deep()

◆ list_copy_head()

◆ list_copy_tail()

◆ list_deduplicate_oid()

◆ list_delete()

◆ list_delete_cell()

◆ list_delete_first()

◆ list_delete_first_n()

◆ list_delete_int()

◆ list_delete_last()

◆ list_delete_nth_cell()

◆ list_delete_oid()

◆ list_delete_ptr()

◆ list_difference()

◆ list_difference_int()

◆ list_difference_oid()

◆ list_difference_ptr()

◆ list_free()

◆ list_free_deep()

◆ list_free_private()

◆ list_insert_nth()

◆ list_insert_nth_int()

◆ list_insert_nth_oid()

◆ list_int_cmp()

◆ list_intersection()

◆ list_intersection_int()

◆ list_make1_impl()

◆ list_make2_impl()

◆ list_make3_impl()

◆ list_make4_impl()

◆ list_make5_impl()

◆ list_member()

◆ list_member_int()

◆ list_member_oid()

◆ list_member_ptr()

◆ list_member_xid()

◆ list_oid_cmp()

◆ list_sort()

◆ list_truncate()

◆ list_union()

◆ list_union_int()

◆ list_union_oid()

◆ list_union_ptr()

◆ new_head_cell()

◆ new_list()

◆ new_tail_cell()