list.c File Reference

#include "postgres.h"
#include "common/int.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:

Go to the source code of this file.

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 80 of file list.c.

IsIntegerList

#define IsIntegerList

(

l

)

((l) == NIL || IsA((l), IntList))

Definition at line 56 of file list.c.

IsOidList

#define IsOidList

(

l

)

((l) == NIL || IsA((l), OidList))

Definition at line 57 of file list.c.

IsPointerList

#define IsPointerList

(

l

)

((l) == NIL || IsA((l), List))

Definition at line 55 of file list.c.

IsXidList

#define IsXidList

(

l

)

((l) == NIL || IsA((l), XidList))

Definition at line 58 of file list.c.

LIST_HEADER_OVERHEAD

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

Definition at line 48 of file list.c.

{
    if (list == NIL)
        return;
 
    Assert(list->length > 0);
    Assert(list->length <= list->max_length);
    Assert(list->elements != NULL);
 
    Assert(list->type == T_List ||
           list->type == T_IntList ||
           list->type == T_OidList ||
           list->type == T_XidList);
}
#else
#define check_list_invariants(l)  ((void) 0)
#endif                          /* USE_ASSERT_CHECKING */
 
/*
 * Return a freshly allocated List with room for at least min_size cells.
 *
 * Since empty non-NIL lists are invalid, new_list() sets the initial length
 * to min_size, effectively marking that number of cells as valid; the caller
 * is responsible for filling in their data.
 */
static List *
new_list(NodeTag type, int min_size)
{
    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;
}
 
/*
 * Enlarge an existing non-NIL List to have room for at least min_size cells.
 *
 * This does *not* update list->length, as some callers would find that
 * inconvenient.  (list->length had better be the correct number of existing
 * valid cells, though.)
 */
static void
enlarge_list(List *list, int min_size)
{
    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;
}
 
/*
 * Convenience functions to construct short Lists from given values.
 * (These are normally invoked via the list_makeN macros.)
 */
List *
list_make1_impl(NodeTag t, ListCell datum1)
{
    List       *list = new_list(t, 1);
 
    list->elements[0] = datum1;
    check_list_invariants(list);
    return list;
}
 
List *
list_make2_impl(NodeTag t, ListCell datum1, ListCell datum2)
{
    List       *list = new_list(t, 2);
 
    list->elements[0] = datum1;
    list->elements[1] = datum2;
    check_list_invariants(list);
    return list;
}
 
List *
list_make3_impl(NodeTag t, ListCell datum1, ListCell datum2,
                ListCell datum3)
{
    List       *list = new_list(t, 3);
 
    list->elements[0] = datum1;
    list->elements[1] = datum2;
    list->elements[2] = datum3;
    check_list_invariants(list);
    return list;
}
 
List *
list_make4_impl(NodeTag t, ListCell datum1, ListCell datum2,
                ListCell datum3, ListCell datum4)
{
    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;
}
 
List *
list_make5_impl(NodeTag t, ListCell datum1, ListCell datum2,
                ListCell datum3, ListCell datum4, ListCell datum5)
{
    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;
}
 
/*
 * Make room for a new head cell in the given (non-NIL) list.
 *
 * The data in the new head cell is undefined; the caller should be
 * sure to fill it in
 */
static void
new_head_cell(List *list)
{
    /* 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++;
}
 
/*
 * Make room for a new tail cell in the given (non-NIL) list.
 *
 * The data in the new tail cell is undefined; the caller should be
 * sure to fill it in
 */
static void
new_tail_cell(List *list)
{
    /* Enlarge array if necessary */
    if (list->length >= list->max_length)
        enlarge_list(list, list->length + 1);
    list->length++;
}
 
/*
 * Append a pointer to the list. A pointer to the modified list is
 * returned. Note that this function may or may not destructively
 * modify the list; callers should always use this function's return
 * value, rather than continuing to use the pointer passed as the
 * first argument.
 */
List *
lappend(List *list, void *datum)
{
    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;
}
 
/*
 * Append an integer to the specified list. See lappend()
 */
List *
lappend_int(List *list, int datum)
{
    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;
}
 
/*
 * Append an OID to the specified list. See lappend()
 */
List *
lappend_oid(List *list, Oid datum)
{
    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;
}
 
/*
 * Append a TransactionId to the specified list. See lappend()
 */
List *
lappend_xid(List *list, TransactionId datum)
{
    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;
}
 
/*
 * Make room for a new cell at position 'pos' (measured from 0).
 * The data in the cell is left undefined, and must be filled in by the
 * caller. 'list' is assumed to be non-NIL, and 'pos' must be a valid
 * list position, ie, 0 <= pos <= list's length.
 * Returns address of the new cell.
 */
static ListCell *
insert_new_cell(List *list, int pos)
{
    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];
}
 
/*
 * Insert the given datum at position 'pos' (measured from 0) in the list.
 * 'pos' must be valid, ie, 0 <= pos <= list's length.
 *
 * Note that this takes time proportional to the distance to the end of the
 * list, since the following entries must be moved.
 */
List *
list_insert_nth(List *list, int pos, void *datum)
{
    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;
}
 
List *
list_insert_nth_int(List *list, int pos, int datum)
{
    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;
}
 
List *
list_insert_nth_oid(List *list, int pos, Oid datum)
{
    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;
}
 
/*
 * Prepend a new element to the list. A pointer to the modified list
 * is returned. Note that this function may or may not destructively
 * modify the list; callers should always use this function's return
 * value, rather than continuing to use the pointer passed as the
 * second argument.
 *
 * Note that this takes time proportional to the length of the list,
 * since the existing entries must be moved.
 *
 * Caution: before Postgres 8.0, the original List was unmodified and
 * could be considered to retain its separate identity.  This is no longer
 * the case.
 */
List *
lcons(void *datum, List *list)
{
    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;
}
 
/*
 * Prepend an integer to the list. See lcons()
 */
List *
lcons_int(int datum, List *list)
{
    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;
}
 
/*
 * Prepend an OID to the list. See lcons()
 */
List *
lcons_oid(Oid datum, List *list)
{
    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;
}
 
/*
 * 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.
 *
 * Note that this takes at least time proportional to the length of list2.
 * It'd typically be the case that we have to enlarge list1's storage,
 * probably adding time proportional to the length of list1.
 */
List *
list_concat(List *list1, const List *list2)
{
    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;
}
 
/*
 * 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
 * pointer returned by this function to refer to the newly truncated
 * list -- it may or may not be the same as the pointer that was
 * passed.
 *
 * Note that any cells removed by list_truncate() are NOT pfree'd.
 */
List *
list_truncate(List *list, int new_size)
{
    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;
}
 
/*
 * Return true iff 'datum' is a member of the list. Equality is
 * determined via equal(), so callers should ensure that they pass a
 * Node as 'datum'.
 *
 * This does a simple linear search --- avoid using it on long lists.
 */
bool
list_member(const List *list, const void *datum)
{
    const ListCell *cell;
 
    Assert(IsPointerList(list));
    check_list_invariants(list);
 
    foreach(cell, list)
    {
        if (equal(lfirst(cell), datum))
            return true;
    }
 
    return false;
}
 
/*
 * Return true iff 'datum' is a member of the list. Equality is
 * determined by using simple pointer comparison.
 */
bool
list_member_ptr(const List *list, const void *datum)
{
    const ListCell *cell;
 
    Assert(IsPointerList(list));
    check_list_invariants(list);
 
    foreach(cell, list)
    {
        if (lfirst(cell) == datum)
            return true;
    }
 
    return false;
}
 
/*
 * Return true iff the integer 'datum' is a member of the list.
 */
bool
list_member_int(const List *list, int datum)
{
    const ListCell *cell;
 
    Assert(IsIntegerList(list));
    check_list_invariants(list);
 
    foreach(cell, list)
    {
        if (lfirst_int(cell) == datum)
            return true;
    }
 
    return false;
}
 
/*
 * Return true iff the OID 'datum' is a member of the list.
 */
bool
list_member_oid(const List *list, Oid datum)
{
    const ListCell *cell;
 
    Assert(IsOidList(list));
    check_list_invariants(list);
 
    foreach(cell, list)
    {
        if (lfirst_oid(cell) == datum)
            return true;
    }
 
    return false;
}
 
/*
 * Return true iff the TransactionId 'datum' is a member of the list.
 */
bool
list_member_xid(const List *list, TransactionId datum)
{
    const ListCell *cell;
 
    Assert(IsXidList(list));
    check_list_invariants(list);
 
    foreach(cell, list)
    {
        if (lfirst_xid(cell) == datum)
            return true;
    }
 
    return false;
}
 
/*
 * Delete the n'th cell (counting from 0) in list.
 *
 * The List is pfree'd if this was the last member.
 *
 * Note that this takes time proportional to the distance to the end of the
 * list, since the following entries must be moved.
 */
List *
list_delete_nth_cell(List *list, int n)
{
    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;
}
 
/*
 * Delete 'cell' from 'list'.
 *
 * The List is pfree'd if this was the last member.  However, we do not
 * touch any data the cell might've been pointing to.
 *
 * Note that this takes time proportional to the distance to the end of the
 * list, since the following entries must be moved.
 */
List *
list_delete_cell(List *list, ListCell *cell)
{
    return list_delete_nth_cell(list, cell - list->elements);
}
 
/*
 * Delete the first cell in list that matches datum, if any.
 * Equality is determined via equal().
 *
 * This does a simple linear search --- avoid using it on long lists.
 */
List *
list_delete(List *list, void *datum)
{
    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;
}
 
/* As above, but use simple pointer equality */
List *
list_delete_ptr(List *list, void *datum)
{
    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;
}
 
/* As above, but for integers */
List *
list_delete_int(List *list, int datum)
{
    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;
}
 
/* As above, but for OIDs */
List *
list_delete_oid(List *list, Oid datum)
{
    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;
}
 
/*
 * Delete the first element of the list.
 *
 * This is useful to replace the Lisp-y code "list = lnext(list);" in cases
 * where the intent is to alter the list rather than just traverse it.
 * Beware that the list is modified, whereas the Lisp-y coding leaves
 * the original list head intact in case there's another pointer to it.
 *
 * Note that this takes time proportional to the length of the list,
 * since the remaining entries must be moved.  Consider reversing the
 * list order so that you can use list_delete_last() instead.  However,
 * if that causes you to replace lappend() with lcons(), you haven't
 * improved matters.  (In short, you can make an efficient stack from
 * a List, but not an efficient FIFO queue.)
 */
List *
list_delete_first(List *list)
{
    check_list_invariants(list);
 
    if (list == NIL)
        return NIL;             /* would an error be better? */
 
    return list_delete_nth_cell(list, 0);
}
 
/*
 * Delete the last element of the list.
 */
List *
list_delete_last(List *list)
{
    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);
}
 
/*
 * Delete the first N cells of the list.
 *
 * The List is pfree'd if the request causes all cells to be deleted.
 *
 * Note that this takes time proportional to the distance to the end of the
 * list, since the following entries must be moved.
 */
List *
list_delete_first_n(List *list, int n)
{
    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;
}
 
/*
 * Generate the union of two lists. This is calculated by copying
 * list1 via list_copy(), then adding to it all the members of list2
 * that aren't already in list1.
 *
 * Whether an element is already a member of the list is determined
 * via equal().
 *
 * The returned list is newly-allocated, although the content of the
 * cells is the same (i.e. any pointed-to objects are not copied).
 *
 * NB: this function will NOT remove any duplicates that are present
 * in list1 (so it only performs a "union" if list1 is known unique to
 * start with).  Also, if you are about to write "x = list_union(x, y)"
 * you probably want to use list_concat_unique() instead to avoid wasting
 * the storage of the old x list.
 *
 * Note that this takes time proportional to the product of the list
 * lengths, so beware of using it on long lists.  (We could probably
 * improve that, but really you should be using some other data structure
 * if this'd be a performance bottleneck.)
 */
List *
list_union(const List *list1, const List *list2)
{
    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;
}
 
/*
 * This variant of list_union() determines duplicates via simple
 * pointer comparison.
 */
List *
list_union_ptr(const List *list1, const List *list2)
{
    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;
}
 
/*
 * This variant of list_union() operates upon lists of integers.
 */
List *
list_union_int(const List *list1, const List *list2)
{
    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;
}
 
/*
 * This variant of list_union() operates upon lists of OIDs.
 */
List *
list_union_oid(const List *list1, const List *list2)
{
    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;
}
 
/*
 * Return a list that contains all the cells that are in both list1 and
 * list2.  The returned list is freshly allocated via palloc(), but the
 * cells themselves point to the same objects as the cells of the
 * input lists.
 *
 * Duplicate entries in list1 will not be suppressed, so it's only a true
 * "intersection" if list1 is known unique beforehand.
 *
 * This variant works on lists of pointers, and determines list
 * membership via equal().  Note that the list1 member will be pointed
 * to in the result.
 *
 * Note that this takes time proportional to the product of the list
 * lengths, so beware of using it on long lists.  (We could probably
 * improve that, but really you should be using some other data structure
 * if this'd be a performance bottleneck.)
 */
List *
list_intersection(const List *list1, const List *list2)
{
    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;
}
 
/*
 * As list_intersection but operates on lists of integers.
 */
List *
list_intersection_int(const List *list1, const List *list2)
{
    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;
}
 
/*
 * Return a list that contains all the cells in list1 that are not in
 * list2. The returned list is freshly allocated via palloc(), but the
 * cells themselves point to the same objects as the cells of the
 * input lists.
 *
 * This variant works on lists of pointers, and determines list
 * membership via equal()
 *
 * Note that this takes time proportional to the product of the list
 * lengths, so beware of using it on long lists.  (We could probably
 * improve that, but really you should be using some other data structure
 * if this'd be a performance bottleneck.)
 */
List *
list_difference(const List *list1, const List *list2)
{
    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;
}
 
/*
 * This variant of list_difference() determines list membership via
 * simple pointer equality.
 */
List *
list_difference_ptr(const List *list1, const List *list2)
{
    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;
}
 
/*
 * This variant of list_difference() operates upon lists of integers.
 */
List *
list_difference_int(const List *list1, const List *list2)
{
    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;
}
 
/*
 * This variant of list_difference() operates upon lists of OIDs.
 */
List *
list_difference_oid(const List *list1, const List *list2)
{
    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;
}
 
/*
 * Append datum to list, but only if it isn't already in the list.
 *
 * Whether an element is already a member of the list is determined
 * via equal().
 *
 * This does a simple linear search --- avoid using it on long lists.
 */
List *
list_append_unique(List *list, void *datum)
{
    if (list_member(list, datum))
        return list;
    else
        return lappend(list, datum);
}
 
/*
 * This variant of list_append_unique() determines list membership via
 * simple pointer equality.
 */
List *
list_append_unique_ptr(List *list, void *datum)
{
    if (list_member_ptr(list, datum))
        return list;
    else
        return lappend(list, datum);
}
 
/*
 * This variant of list_append_unique() operates upon lists of integers.
 */
List *
list_append_unique_int(List *list, int datum)
{
    if (list_member_int(list, datum))
        return list;
    else
        return lappend_int(list, datum);
}
 
/*
 * This variant of list_append_unique() operates upon lists of OIDs.
 */
List *
list_append_unique_oid(List *list, Oid datum)
{
    if (list_member_oid(list, datum))
        return list;
    else
        return lappend_oid(list, datum);
}
 
/*
 * Append to list1 each member of list2 that isn't already in list1.
 *
 * Whether an element is already a member of the list is determined
 * via equal().
 *
 * This is almost the same functionality as list_union(), but list1 is
 * modified in-place rather than being copied. However, callers of this
 * function may have strict ordering expectations -- i.e. that the relative
 * order of those list2 elements that are not duplicates is preserved.
 *
 * Note that this takes time proportional to the product of the list
 * lengths, so beware of using it on long lists.  (We could probably
 * improve that, but really you should be using some other data structure
 * if this'd be a performance bottleneck.)
 */
List *
list_concat_unique(List *list1, const List *list2)
{
    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;
}
 
/*
 * This variant of list_concat_unique() determines list membership via
 * simple pointer equality.
 */
List *
list_concat_unique_ptr(List *list1, const List *list2)
{
    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;
}
 
/*
 * This variant of list_concat_unique() operates upon lists of integers.
 */
List *
list_concat_unique_int(List *list1, const List *list2)
{
    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;
}
 
/*
 * This variant of list_concat_unique() operates upon lists of OIDs.
 */
List *
list_concat_unique_oid(List *list1, const List *list2)
{
    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;
}
 
/*
 * Remove adjacent duplicates in a list of OIDs.
 *
 * It is caller's responsibility to have sorted the list to bring duplicates
 * together, perhaps via list_sort(list, list_oid_cmp).
 *
 * Note that this takes time proportional to the length of the list.
 */
void
list_deduplicate_oid(List *list)
{
    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);
}
 
/*
 * Free all storage in a list, and optionally the pointed-to elements
 */
static void
list_free_private(List *list, bool deep)
{
    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);
}
 
/*
 * Free all the cells of the list, as well as the list itself. Any
 * objects that are pointed-to by the cells of the list are NOT
 * free'd.
 *
 * On return, the argument to this function has been freed, so the
 * caller would be wise to set it to NIL for safety's sake.
 */
void
list_free(List *list)
{
    list_free_private(list, false);
}
 
/*
 * Free all the cells of the list, the list itself, and all the
 * objects pointed-to by the cells of the list (each element in the
 * list must contain a pointer to a palloc()'d region of memory!)
 *
 * On return, the argument to this function has been freed, so the
 * caller would be wise to set it to NIL for safety's sake.
 */
void
list_free_deep(List *list)
{
    /*
     * A "deep" free operation only makes sense on a list of pointers.
     */
    Assert(IsPointerList(list));
    list_free_private(list, true);
}
 
/*
 * Return a shallow copy of the specified list.
 */
List *
list_copy(const List *oldlist)
{
    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;
}
 
/*
 * Return a shallow copy of the specified list containing only the first 'len'
 * elements.  If oldlist is shorter than 'len' then we copy the entire list.
 */
List *
list_copy_head(const List *oldlist, int len)
{
    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;
}
 
/*
 * Return a shallow copy of the specified list, without the first N elements.
 */
List *
list_copy_tail(const List *oldlist, int nskip)
{
    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;
}
 
/*
 * Return a deep copy of the specified list.
 *
 * The list elements are copied via copyObject(), so that this function's
 * idea of a "deep" copy is considerably deeper than what list_free_deep()
 * means by the same word.
 */
List *
list_copy_deep(const List *oldlist)
{
    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;
}
 
/*
 * Sort a list according to the specified comparator function.
 *
 * The list is sorted in-place.
 *
 * The comparator function is declared to receive arguments of type
 * const ListCell *; this allows it to use lfirst() and variants
 * without casting its arguments.  Otherwise it behaves the same as
 * the comparator function for standard qsort().
 *
 * Like qsort(), this provides no guarantees about sort stability
 * for equal keys.
 *
 * This is based on qsort(), so it likewise has O(N log N) runtime.
 */
void
list_sort(List *list, list_sort_comparator cmp)
{
    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);
}
 
/*
 * list_sort comparator for sorting a list into ascending int order.
 */
int
list_int_cmp(const ListCell *p1, const ListCell *p2)
{
    int         v1 = lfirst_int(p1);
    int         v2 = lfirst_int(p2);
 
    return pg_cmp_s32(v1, v2);
}
 
/*
 * list_sort comparator for sorting a list into ascending OID order.
 */
int
list_oid_cmp(const ListCell *p1, const ListCell *p2)
{
    Oid         v1 = lfirst_oid(p1);
    Oid         v2 = lfirst_oid(p2);
 
    return pg_cmp_u32(v1, v2);
}

Function Documentation

enlarge_list()

static void enlarge_list ( List *  list, int  min_size  )

static

Definition at line 155 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, fb(), GetMemoryChunkContext(), 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 415 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 fb().

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

lappend()

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

Definition at line 339 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, fb(), IsPointerList, llast, new_list(), new_tail_cell(), and NIL.

Referenced by _SPI_make_plan_non_temp(), _SPI_prepare_oneshot_plan(), _SPI_prepare_plan(), _SPI_save_plan(), accumulate_append_subpath(), AcquireRewriteLocks(), add_base_clause_to_rel(), add_child_eq_member(), add_column_to_pathtarget(), add_dummy_return(), add_eq_member(), add_join_clause_to_rels(), add_join_rel(), add_local_reloption(), add_merged_range_bounds(), add_outer_joins_to_relids(), add_part_relids(), add_paths_to_append_rel(), add_placeholders_to_base_rels(), add_placeholders_to_joinrel(), add_row_identity_var(), add_rte_to_flat_rtable(), add_security_quals(), add_to_flat_tlist(), add_unique_group_var(), add_vars_to_targetlist(), add_with_check_options(), addArc(), AddEventToPendingNotifies(), addFamilyMember(), addFkRecurseReferencing(), addKey(), addKeyToQueue(), addNSItemToQuery(), addRangeTableEntry(), addRangeTableEntryForCTE(), addRangeTableEntryForENR(), addRangeTableEntryForFunction(), addRangeTableEntryForGroup(), addRangeTableEntryForJoin(), addRangeTableEntryForRelation(), addRangeTableEntryForSubquery(), addRangeTableEntryForTableFunc(), addRangeTableEntryForValues(), AddRelationNewConstraints(), AddRelationNotNullConstraints(), addRTEPermissionInfo(), addTargetToGroupList(), addTargetToSortList(), AlterPublicationTables(), AlterSubscription_refresh(), AlterTableMoveAll(), AlterTSDictionary(), analyzeCTE(), analyzeCTETargetList(), append_pathkeys(), apply_child_basequals(), apply_handle_truncate(), apply_scanjoin_target_to_paths(), applyLockingClause(), ApplyRetrieveRule(), array_subscript_transform(), assign_param_for_placeholdervar(), assign_param_for_var(), ATAddCheckNNConstraint(), ATExecAddColumn(), ATExecAlterConstrEnforceability(), ATExecSetExpression(), ATExecSplitPartition(), ATGetQueueEntry(), ATParseTransformCmd(), ATPostAlterTypeCleanup(), ATPostAlterTypeParse(), ATPrepAlterColumnType(), ATPrepCmd(), BaseBackupAddTarget(), btcostestimate(), build_aggregate_finalfn_expr(), build_aggregate_transfn_expr(), build_coercion_expression(), build_index_pathkeys(), build_index_paths(), build_index_tlist(), build_join_rel(), build_joinrel_tlist(), build_partition_pathkeys(), build_path_tlist(), build_physical_tlist(), build_remote_returning(), build_subplan(), BuildEventTriggerCache(), BuildOnConflictExcludedTargetlist(), buildRelationAliases(), cached_scansel(), calc_joinrel_size_estimate(), calculate_partition_bound_for_merge(), can_minmax_aggs(), check_index_predicates(), check_selective_binary_conversion(), check_sql_stmt_retval(), check_tuple_attribute(), CheckAndReportConflict(), CheckDuplicateColumnOrPathNames(), checkInsertTargets(), checkSharedDependencies(), checkWellFormedRecursionWalker(), choose_bitmap_and(), choose_plan_name(), ChooseIndexColumnNames(), classifyConditions(), clauselist_apply_dependencies(), CloneFkReferenced(), CloneFkReferencing(), CloneRowTriggersToPartition(), coerce_fn_result_column(), coerce_record_to_complex(), compute_common_attribute(), compute_semi_anti_join_factors(), compute_semijoin_info(), ComputeIndexAttrs(), ComputePartitionAttrs(), consider_groupingsets_paths(), consider_new_or_clause(), convert_ANY_sublink_to_join(), convert_EXISTS_to_ANY(), convert_subquery_pathkeys(), convert_VALUES_to_ANY(), CopyMultiInsertInfoFlush(), CopyMultiInsertInfoSetupBuffer(), cost_incremental_sort(), create_append_plan(), create_bitmap_scan_plan(), create_bitmap_subplan(), create_ctas_nodata(), create_customscan_plan(), create_degenerate_grouping_paths(), create_edata_for_relation(), create_grouping_expr_infos(), create_groupingsets_plan(), create_hashjoin_plan(), create_index_paths(), create_indexscan_plan(), create_merge_append_plan(), create_nestloop_path(), create_nestloop_plan(), create_one_window_path(), create_partitionwise_grouping_paths(), create_tidrangescan_plan(), create_tidscan_plan(), create_unique_paths(), CreateStatistics(), createTableConstraints(), database_to_xmlschema_internal(), deconstruct_distribute(), deconstruct_recurse(), DefineRelation(), DefineSequence(), DefineTSDictionary(), DefineView(), DefineVirtualRelation(), deparseFromExprForRel(), deparseParam(), deparseVar(), dependencies_object_end(), deserialize_deflist(), DetachPartitionFinalize(), determineRecursiveColTypes(), distribute_qual_to_rels(), distribute_row_identity_vars(), do_pg_backup_start(), DoCopy(), ec_add_derived_clause(), estimate_multivariate_bucketsize(), estimate_multivariate_ndistinct(), estimate_num_groups(), eval_const_expressions_mutator(), EvalPlanQualStart(), EventTriggerAlterTableEnd(), EventTriggerCollectAlterDefPrivs(), EventTriggerCollectAlterOpFam(), EventTriggerCollectAlterTableSubcmd(), EventTriggerCollectAlterTSConfig(), EventTriggerCollectCreateOpClass(), EventTriggerCollectGrant(), EventTriggerCollectSimpleCommand(), ExecAllocTableSlot(), ExecDoInitialPruning(), ExecEvalXmlExpr(), ExecGetAncestorResultRels(), ExecGetTriggerResultRel(), ExecInitExprList(), ExecInitExprRec(), ExecInitInsertProjection(), ExecInitJsonExpr(), ExecInitLockRows(), ExecInitMerge(), ExecInitModifyTable(), ExecInitNode(), ExecInitPartitionInfo(), ExecInitResultRelation(), ExecInitSubPlan(), ExecInitSubPlanExpr(), ExecInsert(), ExecPrepareExprList(), ExecSerializePlan(), ExecuteGrantStmt(), ExecuteTruncate(), ExecuteTruncateGuts(), expand_generated_columns_internal(), expand_grouping_sets(), expand_groupingset_node(), expand_inherited_rtentry(), expand_insert_targetlist(), expand_single_inheritance_child(), expand_vacuum_rel(), expand_virtual_generated_columns(), expandNSItemAttrs(), expandNSItemVars(), ExpandRowReference(), expandRTE(), expandTableLikeClause(), expandTupleDesc(), ExplainNode(), ExportSnapshot(), expr_setup_walker(), expression_tree_mutator_impl(), extract_actual_clauses(), extract_actual_join_clauses(), extract_jsp_path_expr_nodes(), extract_lateral_references(), extract_lateral_vars_from_PHVs(), extract_nonindex_conditions(), extract_or_clause(), extract_rollup_sets(), extract_slot_names(), extractRemainingColumns(), fetch_relation_list(), fetch_remote_slots(), fetch_remote_table_info(), fetch_statentries_for_relation(), fetch_upper_rel(), FetchRelationStates(), file_fdw_validator(), fill_hba_line(), FilterWalSummaries(), find_duplicate_ors(), find_hash_columns(), find_indexpath_quals(), find_list_position(), find_mergeclauses_for_outer_pathkeys(), find_partition_scheme(), find_placeholder_info(), find_window_functions_walker(), find_window_run_conditions(), findTargetlistEntrySQL99(), fireRIRrules(), fireRules(), fix_indexorderby_references(), fix_indexqual_references(), flatten_grouping_sets(), flatten_join_alias_vars_mutator(), flatten_simple_union_all(), fmgr_security_definer(), fmgr_sql_validator(), foreign_grouping_ok(), foreign_join_ok(), format_operator_parts(), format_procedure_parts(), func_get_detail(), gen_partprune_steps_internal(), gen_prune_step_combine(), gen_prune_step_op(), gen_prune_steps_from_opexps(), generate_append_tlist(), generate_bitmap_or_paths(), generate_implied_equalities_for_column(), generate_join_implied_equalities_broken(), generate_join_implied_equalities_normal(), generate_matching_part_pairs(), generate_orderedappend_paths(), generate_partitionwise_join_paths(), generate_setop_tlist(), generate_subquery_params(), generate_subquery_vars(), generate_union_paths(), generateClonedExtStatsStmt(), generateClonedIndexStmt(), generateJsonTablePathName(), generateSerialExtraStmts(), get_actual_clauses(), get_all_vacuum_rels(), get_appendrel_parampathinfo(), get_baserel_parampathinfo(), get_database_list(), get_eclass_for_sort_expr(), get_ext_ver_info(), get_ext_ver_list(), get_extension_control_directories(), get_file_fdw_attribute_options(), get_foreign_key_join_selectivity(), get_func_expr(), get_index_clause_from_support(), get_index_paths(), get_insert_query_def(), get_join_index_paths(), get_joinrel_parampathinfo(), get_local_synced_slots(), get_matching_part_pairs(), get_merge_query_def(), get_op_index_interpretation(), get_policies_for_relation(), get_qual_for_hash(), get_qual_for_list(), get_qual_for_range(), get_quals_from_indexclauses(), get_range_nulltest(), get_rel_sync_entry(), get_relation_constraints(), get_relation_foreign_keys(), get_relation_statistics_worker(), get_rels_with_domain(), get_required_extension(), get_sortgrouplist_exprs(), get_steps_using_prefix_recurse(), get_subscription_list(), get_switched_clauses(), get_tables_to_cluster(), get_tables_to_cluster_partitioned(), get_tlist_exprs(), get_update_query_targetlist_def(), get_useful_ecs_for_relation(), get_useful_group_keys_orderings(), get_useful_pathkeys_for_distinct(), get_useful_pathkeys_for_relation(), get_useful_pathkeys_for_relation(), get_windowfunc_expr_helper(), GetAfterTriggersTableData(), getAttributesList(), getObjectIdentityParts(), getState(), GetSubscriptionRelations(), getTokenTypes(), GetWalSummaries(), gistFindPath(), gistfixsplit(), gistplacetopage(), group_keys_reorder_by_pathkeys(), group_similar_or_args(), grouping_planner(), hash_inner_and_outer(), hashagg_spill_finish(), heap_truncate(), identify_current_nestloop_params(), identify_opfamily_groups(), index_concurrently_create_copy(), infer_arbiter_indexes(), init_grouping_targets(), initialize_target_list(), InitPlan(), injection_points_attach(), InjectionPointList(), innerrel_is_unique_ext(), interpret_AS_clause(), interpret_function_parameter_list(), intorel_startup(), is_innerrel_unique_for(), join_is_removable(), jsonb_ops__extract_nodes(), jsonb_path_ops__extract_nodes(), jsonb_subscript_transform(), JsonTableInitOpaque(), JsonValueListAppend(), list_append_unique(), list_append_unique_ptr(), list_concat_unique(), list_concat_unique_ptr(), list_difference(), list_difference_ptr(), list_intersection(), list_union(), list_union_ptr(), llvm_compile_module(), load_hba(), load_ident(), LoadPublications(), Lock_AF_UNIX(), logicalrep_workers_find(), LogicalRepSyncSequences(), make_bitmap_paths_for_or_group(), make_canonical_pathkey(), make_copy_attnamelist(), make_group_input_target(), make_inh_translation_list(), make_inner_pathkeys_for_merge(), make_modifytable(), make_partial_grouping_target(), make_partition_op_expr(), make_partition_pruneinfo(), make_partitionedrel_pruneinfo(), make_path_rowexpr(), make_pathkeys_for_sortclauses_extended(), make_pathtarget_from_tlist(), make_rel_from_joinlist(), make_row_comparison_op(), make_setop_translation_list(), make_sort_input_target(), make_sub_restrictinfos(), make_tlist_from_pathtarget(), make_window_input_target(), manifest_process_wal_range(), MarkGUCPrefixReserved(), markRelsAsNulledBy(), match_clause_to_index(), match_clause_to_partition_key(), match_foreign_keys_to_quals(), match_network_subset(), match_orclause_to_indexcol(), match_pathkeys_to_index(), match_pattern_prefix(), matchLocks(), mbms_add_member(), mbms_add_members(), merge_clump(), merge_list_bounds(), merge_publications(), MergeAttributes(), MergeCheckConstraint(), ndistinct_object_end(), negate_clause(), next_field_expand(), nodeRead(), ObjectsInPublicationToOids(), OpenTableList(), order_qual_clauses(), pa_launch_parallel_worker(), paraminfo_get_equal_hashops(), parse_hba_line(), parseCheckAggregates(), ParseFuncOrColumn(), PartConstraintImpliedByRelConstraint(), partitions_listdatum_intersection(), perform_base_backup(), pg_available_extension_versions(), pg_available_extensions(), pg_get_backend_memory_contexts(), pg_get_object_address(), pg_get_publication_tables(), pg_logical_slot_get_changes_guts(), pg_plan_queries(), pg_rewrite_query(), pgfdw_abort_cleanup_begin(), pgfdw_finish_abort_cleanup(), pgfdw_finish_pre_commit_cleanup(), pgfdw_subxact_callback(), pgfdw_xact_callback(), pgoutput_row_filter_init(), plan_union_children(), populate_typ_list(), postgresGetForeignPaths(), postgresGetForeignPlan(), postgresImportForeignSchema(), PreCommit_Notify(), prep_domain_constraints(), prepare_next_query(), prepare_sort_from_pathkeys(), preprocess_aggref(), preprocess_groupclause(), preprocess_grouping_sets(), preprocess_rowmarks(), preprocess_targetlist(), process_duplicate_ors(), process_equivalence(), process_pipe_input(), process_sublinks_mutator(), process_subquery_nestloop_params(), ProcessStartupPacket(), pull_ands(), pull_ors(), pull_up_simple_values(), pull_up_sublinks_jointree_recurse(), pull_up_sublinks_qual_recurse(), pull_up_union_leaf_queries(), pull_var_clause_walker(), pull_vars_walker(), query_tree_mutator_impl(), QueryRewrite(), queue_listen(), QueueCheckConstraintValidation(), QueueFKConstraintValidation(), range_table_mutator_impl(), read_tablespace_map(), rebuild_fdw_scan_tlist(), RebuildConstraintComment(), record_plan_function_dependency(), record_plan_type_dependency(), reduce_outer_joins_pass1(), register_ENR(), register_label_provider(), register_partpruneinfo(), register_reloptions_validator(), ReindexRelationConcurrently(), relation_excluded_by_constraints(), relation_has_unique_index_for(), RelationCacheInvalidate(), RelationGetDummyIndexExpressions(), RelationGetFKeyList(), RelationGetNotNullConstraints(), remap_to_groupclause_idx(), RememberConstraintForRebuilding(), RememberIndexForRebuilding(), RememberStatisticsForRebuilding(), RememberSyncRequest(), remove_rel_from_joinlist(), remove_self_join_rel(), remove_useless_groupby_columns(), RemoveInheritance(), reorder_function_arguments(), reparameterize_path(), reparameterize_path_by_child(), reparameterize_pathlist_by_child(), replace_empty_jointree(), replace_nestloop_param_placeholdervar(), replace_nestloop_param_var(), replace_outer_agg(), replace_outer_grouping(), replace_outer_merge_support(), replace_outer_returning(), ReplaceVarFromTargetList(), report_reduced_full_join(), resolve_unique_index_expr(), RewriteQuery(), rewriteSearchAndCycle(), rewriteTargetListIU(), rewriteTargetView(), rewriteValuesRTE(), rewriteValuesRTEToNulls(), RI_Initial_Check(), ScanSourceDatabasePgClassPage(), schema_to_xmlschema_internal(), SearchCatCacheList(), select_active_windows(), select_mergejoin_clauses(), select_outer_pathkeys_for_merge(), sepgsql_set_client_label(), sequence_options(), set_append_rel_pathlist(), set_append_rel_size(), set_cheapest(), set_deparse_for_query(), set_dummy_tlist_references(), set_indexonlyscan_references(), set_joinrel_partition_key_exprs(), set_plan_references(), set_plan_refs(), set_rtable_names(), set_simple_column_names(), set_subquery_pathlist(), set_upper_references(), set_using_names(), show_grouping_set_keys(), show_incremental_sort_group_info(), show_modifytable_info(), show_plan_tlist(), show_sort_group_keys(), show_tablesample(), simplify_and_arguments(), simplify_or_arguments(), split_pathtarget_at_srfs_extended(), split_pathtarget_walker(), split_selfjoin_quals(), SplitDirectoriesString(), SplitGUCList(), SplitIdentifierString(), SplitPartitionMoveRows(), SS_make_initplan_from_plan(), SS_process_ctes(), statext_is_compatible_clause_internal(), statext_mcv_clauselist_selectivity(), stringToQualifiedNameList(), subquery_planner(), table_slot_create(), textarray_to_stringlist(), textarray_to_strvaluelist(), textToQualifiedNameList(), TidExprListCreate(), TidExprListCreate(), TidRangeQualFromRestrictInfoList(), tokenize_auth_file(), tokenize_expand_file(), transform_MERGE_to_join(), transformAExprIn(), transformAggregateCall(), transformAlterTableStmt(), transformArrayExpr(), transformAssignmentIndirection(), transformBoolExpr(), transformCallStmt(), transformCaseExpr(), transformCoalesceExpr(), transformColumnDefinition(), transformCreateSchemaStmtElements(), transformCreateStmt(), transformDistinctClause(), transformDistinctOnClause(), transformExpressionList(), transformFKConstraints(), transformFkeyGetPrimaryKey(), transformFromClause(), transformFromClauseItem(), transformFuncCall(), transformGenericOptions(), transformGroupClause(), transformGroupClauseExpr(), transformGroupingFunc(), transformGroupingSet(), TransformGUCArray(), transformIndexConstraint(), transformIndexConstraints(), transformIndirection(), transformInsertRow(), transformInsertStmt(), transformJoinUsingClause(), transformJsonArrayConstructor(), transformJsonObjectConstructor(), transformJsonPassingArgs(), transformJsonTableColumns(), transformMergeStmt(), transformMinMaxExpr(), transformMultiAssignRef(), transformOfType(), transformPartitionBound(), transformPartitionRangeBounds(), transformPartitionSpec(), transformPLAssignStmt(), transformRangeFunction(), transformRangeTableFunc(), transformRangeTableSample(), transformRowExpr(), transformRuleStmt(), transformSetOperationStmt(), transformSetOperationTree(), transformSubLink(), transformTableConstraint(), transformTableLikeClause(), transformTargetList(), transformValuesClause(), transformWindowDefinitions(), transformWindowFuncCall(), transformWithClause(), transformXmlExpr(), trim_mergeclauses_for_inner_pathkeys(), TS_execute_locations_recurse(), untransformRelOptions(), update_eclasses(), UpdateLogicalMappings(), WaitForLockersMultiple(), WalkInnerWith(), and xmlelement().

lappend_int()

List * lappend_int	(	List *	list,
		int	datum
	)

Definition at line 357 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, fb(), IsIntegerList, llast_int, new_list(), new_tail_cell(), and NIL.

Referenced by add_merged_range_bounds(), addRangeTableEntryForCTE(), addRangeTableEntryForENR(), addRangeTableEntryForFunction(), addRangeTableEntryForGroup(), addRangeTableEntryForSubquery(), AddRelationNotNullConstraints(), adjust_inherited_attnums(), adjust_partition_colnos_using_map(), analyzeCTETargetList(), ATRewriteTable(), build_merged_partition_bounds(), build_subplan(), checkInsertTargets(), convert_EXISTS_to_ANY(), copy_sequences(), CopyGetAttnums(), create_grouping_expr_infos(), deparseAnalyzeSql(), deparseExplicitTargetList(), deparseTargetList(), dependencies_scalar(), ExecBuildAggTrans(), ExecBuildGroupingEqual(), ExecBuildHash32Expr(), ExecBuildParamSetEqual(), ExecConstraints(), ExecInitExprRec(), ExecInitJsonExpr(), ExecInitModifyTable(), ExecInitPartitionInfo(), 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(), ndistinct_scalar(), nodeRead(), plan_union_children(), postgresBeginForeignInsert(), postgresPlanForeignModify(), rel_is_distinct_for(), remap_to_groupclause_idx(), RemoveInheritance(), reorder_grouping_sets(), rewriteSearchAndCycle(), set_plan_refs(), split_pathtarget_at_srfs_extended(), SS_process_ctes(), substitute_grouped_columns_mutator(), TerminateOtherDBBackends(), test_bms_overlap_list(), transformDistinctOnClause(), transformFromClauseItem(), transformGroupClauseList(), transformInsertStmt(), transformJsonTableColumns(), transformRangeTableFunc(), transformSetOperationTree(), and transformValuesClause().

lappend_oid()

List * lappend_oid	(	List *	list,
		Oid	datum
	)

Definition at line 375 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, fb(), IsOidList, llast_oid, new_list(), new_tail_cell(), and NIL.

Referenced by add_rte_to_flat_rtable(), addRangeTableEntryForCTE(), addRangeTableEntryForENR(), addRangeTableEntryForFunction(), addRangeTableEntryForGroup(), addRangeTableEntryForSubquery(), AfterTriggerSetState(), AlterTableMoveAll(), analyzeCTETargetList(), apply_handle_truncate(), ApplyExtensionUpdates(), assign_collations_walker(), assign_param_for_placeholdervar(), assign_param_for_var(), assign_special_exec_param(), ATExecMergePartitions(), 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(), DetachPartitionFinalize(), do_autovacuum(), EventTriggerCommonSetup(), ExecAlterDefaultPrivilegesStmt(), ExecInitPartitionInfo(), ExecInsertIndexTuples(), ExecuteGrantStmt(), ExecuteTruncate(), ExecuteTruncateGuts(), expand_indexqual_rowcompare(), extract_query_dependencies_walker(), ExtractExtensionList(), finalNamespacePath(), 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(), GetAllPublicationRelations(), 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(), InitConflictIndexes(), 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(), preprocessNamespacePath(), query_to_oid_list(), ReindexMultipleTables(), ReindexPartitions(), ReindexRelationConcurrently(), rel_is_distinct_for(), relation_is_updatable(), RelationGetIndexList(), RelationGetStatExtList(), RememberConstraintForRebuilding(), RememberIndexForRebuilding(), RememberStatisticsForRebuilding(), remove_dbtablespaces(), replace_outer_agg(), replace_outer_grouping(), replace_outer_merge_support(), replace_outer_returning(), RestoreReindexState(), rewriteSearchAndCycle(), roles_list_append(), roleSpecsToIds(), transformAggregateCall(), transformInsertStmt(), transformJsonTableColumns(), transformPartitionCmdForMerge(), transformRangeTableFunc(), transformSetOperationTree(), transformValuesClause(), TryReuseForeignKey(), and typeInheritsFrom().

lappend_xid()

List * lappend_xid	(	List *	list,
		TransactionId	datum
	)

Definition at line 393 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, fb(), IsXidList, 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 495 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, fb(), IsPointerList, linitial, 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(), get_rule_expr(), gistEmptyAllBuffers(), gistFindPath(), gistGetNodeBuffer(), gistPushItupToNodeBuffer(), load_domaintype_info(), pg_get_object_address(), plan_union_children(), PLy_subtransaction_enter(), PrepareClientEncoding(), push_child_plan(), pushOperator(), pushStop(), pushValue_internal(), readTimeLineHistory(), register_on_commit_action(), RelationBuildRowSecurity(), RelationCacheInvalidate(), RememberConstraintForRebuilding(), reorder_grouping_sets(), RewriteQuery(), rewriteSearchAndCycle(), rewriteTargetView(), sepgsql_avc_compute(), set_cheapest(), show_agg_keys(), show_group_keys(), show_window_def(), sort_inner_and_outer(), transformCaseExpr(), and WalkInnerWith().

lcons_int()

List * lcons_int	(	int	datum,
		List *	list
	)

Definition at line 513 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, fb(), IsIntegerList, linitial_int, new_head_cell(), new_list(), and NIL.

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

lcons_oid()

List * lcons_oid	(	Oid	datum,
		List *	list
	)

Definition at line 531 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, fb(), IsOidList, linitial_oid, new_head_cell(), new_list(), and NIL.

Referenced by finalNamespacePath(), pg_partition_ancestors(), ReindexMultipleTables(), and RememberConstraintForRebuilding().

list_append_unique()

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

Definition at line 1343 of file list.c.

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

References lappend(), and list_member().

Referenced by add_security_quals(), add_with_check_options(), check_publications_origin_sequences(), check_publications_origin_tables(), create_agg_clause_infos(), and create_index_paths().

list_append_unique_int()

List * list_append_unique_int	(	List *	list,
		int	datum
	)

Definition at line 1368 of file list.c.

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

References lappend_int(), and list_member_int().

list_append_unique_oid()

List * list_append_unique_oid	(	List *	list,
		Oid	datum
	)

Definition at line 1380 of file list.c.

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

References lappend_oid(), and list_member_oid().

Referenced by AlterConstrTriggerDeferrability(), btvalidate(), DropRole(), hashvalidate(), heap_truncate_find_FKs(), LogicalRepWorkersWakeupAtCommit(), map_sql_typecoll_to_xmlschema_types(), and ObjectsInPublicationToOids().

list_append_unique_ptr()

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

Definition at line 1356 of file list.c.

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

References lappend(), and list_member_ptr().

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

list_concat()

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

Definition at line 561 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, enlarge_list(), fb(), list_copy(), and NIL.

Referenced by accumulate_append_subpath(), add_predicate_to_index_quals(), addRangeTableEntryForJoin(), addRangeTableEntryForTableFunc(), ATParseTransformCmd(), ATPostAlterTypeParse(), AtSubCommit_Notify(), build_joinrel_restrictlist(), build_paths_for_OR(), calculate_partition_bound_for_merge(), check_index_predicates(), choose_bitmap_and(), clean_up_removed_plan_level(), CombineRangeTables(), consider_groupingsets_paths(), ConstraintImpliedByRelConstraint(), cost_index(), create_agg_clause_infos(), create_append_path(), create_append_plan(), create_bitmap_subplan(), create_index_paths(), create_join_plan(), deconstruct_distribute(), deconstruct_recurse(), DefineRelation(), deparseDirectDeleteSql(), deparseDirectUpdateSql(), deparseFromExprForRel(), ec_add_derived_clauses(), estimate_multivariate_bucketsize(), 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(), paraminfo_get_equal_hashops(), PrepareForIncrementalBackup(), process_equivalence(), process_sublinks_mutator(), ProcessUtilitySlow(), pull_ands(), pull_ors(), pull_up_simple_subquery(), reduce_unique_semijoins(), remove_self_join_rel(), remove_self_joins_one_group(), remove_useless_results_recurse(), reorder_grouping_sets(), RewriteQuery(), rewriteRuleAction(), rewriteTargetListIU(), selectColorTrigrams(), set_joinrel_partition_key_exprs(), set_plan_refs(), split_pathtarget_at_srfs_extended(), split_pathtarget_walker(), subquery_planner(), TidQualFromRestrictInfoList(), transformAExprIn(), transformAlterTableStmt(), transformCreateSchemaStmtElements(), transformCreateStmt(), transformExpressionList(), transformFromClause(), transformFromClauseItem(), transformIndexConstraints(), transformTableLikeClause(), transformTargetList(), TS_execute_locations_recurse(), and vacuum().

list_concat_copy()

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

Definition at line 598 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, fb(), list_copy(), new_list(), and NIL.

Referenced by add_function_defaults(), ATExecAttachPartition(), 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(), 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 1405 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, fb(), 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 1448 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, fb(), 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 1469 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, fb(), IsOidList, lappend_oid(), lfirst_oid, and list_member_oid().

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

list_concat_unique_ptr()

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

Definition at line 1427 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, fb(), IsPointerList, lappend(), lfirst, and list_member_ptr().

Referenced by get_useful_pathkeys_for_distinct(), and group_keys_reorder_by_pathkeys().

list_copy()

List * list_copy

(

const List *

oldlist

)

Definition at line 1573 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, fb(), new_list(), and NIL.

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(), CopySearchPathMatcher(), create_nestloop_plan(), estimate_multivariate_bucketsize(), EventTriggerCollectGrant(), ExecuteTruncateGuts(), expression_tree_mutator_impl(), fetch_search_path(), foreign_join_ok(), generate_bitmap_or_paths(), 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(), GetSearchPathMatcher(), 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(), plpgsql_parse_cwordtype(), preprocess_groupclause(), recomputeNamespacePath(), RelationGetIndexList(), RelationGetStatExtList(), remove_leftjoinrel_from_query(), remove_self_join_rel(), 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(), transformWithClause(), and WalSummariesAreComplete().

list_copy_deep()

List * list_copy_deep

(

const List *

oldlist

)

Definition at line 1639 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(), fb(), i, IsA, lfirst, new_list(), and NIL.

Referenced by copyObjectImpl().

list_copy_head()

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

Definition at line 1593 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, fb(), len, Min, new_list(), and NIL.

Referenced by accumulate_append_subpath(), build_index_paths(), create_agg_path(), create_append_plan(), create_merge_append_plan(), does_not_exist_skipping(), expand_indexqual_rowcompare(), gather_grouping_paths(), get_object_address_attrdef(), get_object_address_attribute(), get_object_address_opf_member(), get_object_address_relobject(), get_useful_pathkeys_for_relation(), group_keys_reorder_by_pathkeys(), 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 1613 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, fb(), new_list(), and NIL.

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 1495 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, 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 853 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, and list_delete_cell().

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

list_delete_cell()

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

Definition at line 841 of file list.c.

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

References list_delete_nth_cell().

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

list_delete_first()

List * list_delete_first

(

List *

list

)

Definition at line 943 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, list_delete_nth_cell(), and NIL.

Referenced by checkWellFormedRecursionWalker(), CopyMultiInsertInfoFlush(), ExplainCloseGroup(), ExplainEndOutput(), ExplainNode(), ExplainSaveGroup(), ExplainSubPlans(), fetch_search_path(), find_expr_references_walker(), get_rule_expr(), GetSearchPathMatcher(), gistEmptyAllBuffers(), gistFindPath(), gistProcessEmptyingQueue(), jsonb_path_query_internal(), plan_union_children(), PLy_abort_open_subtransactions(), PLy_subtransaction_exit(), pop_child_plan(), ProcessUtilitySlow(), show_agg_keys(), show_group_keys(), show_window_def(), simplify_and_arguments(), simplify_or_arguments(), transformPLAssignStmt(), transformWithClause(), and WalkInnerWith().

list_delete_first_n()

List * list_delete_first_n	(	List *	list,
		int	n
	)

Definition at line 983 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, fb(), GetMemoryChunkContext(), 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 891 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, and list_delete_cell().

Referenced by reorder_grouping_sets().

list_delete_last()

List * list_delete_last

(

List *

list

)

Definition at line 957 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, list_free(), list_length(), list_truncate(), and NIL.

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

list_delete_nth_cell()

List * list_delete_nth_cell	(	List *	list,
		int	n
	)

Definition at line 767 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, fb(), GetMemoryChunkContext(), list_free(), MemoryContextAlloc(), NIL, pfree(), and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by AddRelationNotNullConstraints(), 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 910 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, and list_delete_cell().

Referenced by RemoveReindexPending().

list_delete_ptr()

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

Definition at line 872 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, and list_delete_cell().

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

list_difference()

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

Definition at line 1237 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, fb(), IsPointerList, lappend(), lfirst, list_copy(), list_member(), and NIL.

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

list_difference_int()

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

Definition at line 1288 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, fb(), 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 1313 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, fb(), 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 1263 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, fb(), IsPointerList, lappend(), lfirst, list_copy(), list_member_ptr(), and NIL.

Referenced by create_bitmap_scan_plan(), ExecuteTruncateGuts(), and get_useful_group_keys_orderings().

list_free()

void list_free

(

List *

list

)

Definition at line 1546 of file list.c.

{
    list_free_private(list, false);
}

References list_free_private().

Referenced by AfterTriggerSetState(), AlterIndexNamespaces(), arrayconst_cleanup_fn(), arrayexpr_cleanup_fn(), ATCheckPartitionsNotInUse(), ATExecChangeOwner(), ATExecMergePartitions(), ATExecSetTableSpace(), build_base_rel_tlists(), build_remote_returning(), BuildRelationExtStatistics(), cachedNamespacePath(), calc_joinrel_size_estimate(), calculate_indexes_size(), calculate_partition_bound_for_merge(), calculate_toast_table_size(), check_createrole_self_grant(), check_datestyle(), check_debug_io_direct(), check_log_connections(), check_log_destination(), check_restrict_nonsystem_relation_kind(), check_search_path(), check_synchronized_standby_slots(), check_temp_tablespaces(), check_wal_consistency_checking(), choose_bitmap_and(), compute_semi_anti_join_factors(), CopyFrom(), CopyMultiInsertBufferFlush(), CopyMultiInsertInfoCleanup(), create_agg_clause_infos(), CreateExtensionInternal(), CreateTriggerFiringOn(), current_schema(), current_schemas(), DefineIndex(), DefineRelation(), deparseFromExprForRel(), dependencies_object_end(), distribute_qual_to_rels(), do_analyze_rel(), do_autovacuum(), DropSubscription(), ec_clear_derived_clauses(), EndCopy(), estimate_multivariate_bucketsize(), EventTriggerDDLCommandEnd(), EventTriggerDDLCommandStart(), EventTriggerOnLogin(), EventTriggerSQLDrop(), EventTriggerTableRewrite(), ExecInitPartitionInfo(), ExecInsert(), ExecOpenIndices(), ExecPendingInserts(), ExecResetTupleTable(), ExecSimpleRelationInsert(), ExecSimpleRelationUpdate(), ExecUpdateEpilogue(), expandTableLikeClause(), extract_lateral_references(), extract_lateral_vars_from_PHVs(), 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_bitmap_or_paths(), generate_partitionwise_join_paths(), get_rel_sync_entry(), get_relation_info(), get_relation_statistics(), get_steps_using_prefix_recurse(), get_windowclause_startup_tuples(), getIdentitySequence(), GetTopMostAncestorInPublication(), group_keys_reorder_by_pathkeys(), heap_truncate_find_FKs(), index_concurrently_swap(), index_get_partition(), index_unchanged_by_update(), infer_arbiter_indexes(), is_var_in_aggref_only(), list_delete_first_n(), list_delete_last(), list_delete_nth_cell(), llvm_release_context(), logicalrep_worker_detach(), make_group_input_target(), make_partial_grouping_target(), make_SAOP_expr(), make_sort_input_target(), make_window_input_target(), match_orclause_to_indexcol(), max_parallel_hazard_walker(), merge_list_bounds(), merge_range_bounds(), ndistinct_object_end(), ObjectsInPublicationToOids(), OpenTableList(), paraminfo_get_equal_hashops(), parse_hba_auth_opt(), pg_dependencies_in(), pg_ndistinct_in(), pg_partition_root(), plpgsql_extra_checks_check_hook(), pop_ancestor_plan(), PostmasterMain(), PrepareTempTablespaces(), preprocess_targetlist(), preprocessNamespacePath(), process_implied_equality(), ProcessGUCArray(), processState(), ProcessUtilitySlow(), PutMemoryContextsStatsTupleStore(), qual_is_pushdown_safe(), rebuild_eclass_attr_needed(), rebuild_joinclause_attr_needed(), rebuild_placeholder_attr_needed(), recomputeNamespacePath(), refresh_by_match_merge(), RefreshMatViewByOid(), RelationCacheInvalidate(), RelationDestroyRelation(), RelationGetIndexAttrBitmap(), RelationGetIndexList(), RelationGetPrimaryKeyIndex(), RelationGetReplicaIndex(), RelationGetStatExtList(), relationHasPrimaryKey(), remove_dbtablespaces(), remove_self_join_rel(), 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(), test_bms_overlap_list(), textToQualifiedNameList(), toast_open_indexes(), transformFkeyCheckAttrs(), transformFkeyGetPrimaryKey(), transformValuesClause(), triggered_change_notification(), typeInheritsFrom(), update_eclasses(), vac_open_indexes(), and WaitForLockers().

list_free_deep()

void list_free_deep

(

List *

list

)

Definition at line 1560 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, and list_free_private().

Referenced by AfterTriggerFreeQuery(), check_oauth_validator(), checkSharedDependencies(), CloseTableList(), copy_table(), create_agg_clause_infos(), CreateDatabaseUsingWalLog(), createTableConstraints(), deconstruct_jointree(), deparseDirectDeleteSql(), deparseDirectUpdateSql(), deparseFromExpr(), deparseFromExprForRel(), DetachPartitionFinalize(), estimate_multivariate_bucketsize(), fetch_remote_table_info(), FetchRelationStates(), FreeSubscription(), gettype(), gistbufferinginserttuples(), hashagg_reset_spill_state(), load_libraries(), lookup_proof_cache(), pg_dependencies_in(), pg_ndistinct_in(), pgoutput_row_filter_init(), PostmasterMain(), RelationDestroyRelation(), RelationGetFKeyList(), ReplSlotSyncWorkerMain(), rescanLatestTimeLine(), StartReplication(), SyncPostCheckpoint(), SyncReplicationSlots(), verify_heapam(), WaitForLockersMultiple(), XLogReadDetermineTimeline(), and XLogSendPhysical().

list_free_private()

static void list_free_private ( List *  list, bool  deep  )

static

Definition at line 1520 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, fb(), i, lfirst, 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 439 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, 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 453 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, list_make1_int, and NIL.

list_insert_nth_oid()

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

Definition at line 467 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, list_make1_oid, and NIL.

list_int_cmp()

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

Definition at line 1691 of file list.c.

{
    int         v1 = lfirst_int(p1);
    int         v2 = lfirst_int(p2);
 
    return pg_cmp_s32(v1, v2);
}

References fb(), lfirst_int, and pg_cmp_s32().

Referenced by expand_grouping_sets().

list_intersection()

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

Definition at line 1174 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, fb(), IsPointerList, lappend(), lfirst, list_member(), and NIL.

list_intersection_int()

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

Definition at line 1200 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, fb(), 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 236 of file list.c.

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

References check_list_invariants, and new_list().

list_make2_impl()

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

Definition at line 246 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, fb(), and new_list().

list_make3_impl()

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

Definition at line 257 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, fb(), and new_list().

list_make4_impl()

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

Definition at line 270 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, fb(), 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 284 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, fb(), and new_list().

list_member()

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

Definition at line 661 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, and lfirst.

Referenced by add_new_column_to_pathtarget(), analyzeCTE(), build_minmax_path(), consider_index_join_outer_rels(), create_bitmap_scan_plan(), ec_member_matches_foreign(), find_computable_ec_member(), get_join_index_paths(), infer_arbiter_indexes(), init_grouping_targets(), is_var_in_aggref_only(), list_append_unique(), list_concat_unique(), list_difference(), list_intersection(), list_union(), paraminfo_get_equal_hashops(), pg_available_extension_versions(), pg_available_extensions(), process_duplicate_ors(), remove_self_join_rel(), split_pathtarget_at_srfs_extended(), and split_pathtarget_walker().

list_member_int()

bool list_member_int	(	const List *	list,
		int	datum
	)

Definition at line 702 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, and lfirst_int.

Referenced by BeginCopyFrom(), BeginCopyTo(), buildGroupedVar(), 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(), substitute_grouped_columns_mutator(), and transformDistinctOnClause().

list_member_oid()

bool list_member_oid	(	const List *	list,
		Oid	datum
	)

Definition at line 722 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, and lfirst_oid.

Referenced by AfterTriggerSaveEvent(), AlterTableMoveAll(), apply_handle_truncate(), ATExecAddInherit(), ATExecAttachPartition(), ATExecMergePartitions(), BeginCopyTo(), CheckAndReportConflict(), CheckAttributeType(), CloneFkReferenced(), CloneFkReferencing(), CollationIsVisibleExt(), ConversionIsVisibleExt(), DefineRelation(), DetachPartitionFinalize(), ec_member_matches_indexcol(), ExecAlterObjectDependsStmt(), ExecCheckIndexConstraints(), ExecInitPartitionInfo(), ExecInsertIndexTuples(), ExecuteTruncate(), exprs_known_equal(), finalNamespacePath(), fireRIRrules(), FunctionIsVisibleExt(), 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(), OpclassIsVisibleExt(), OpenTableList(), OperatorIsVisibleExt(), OpfamilyIsVisibleExt(), PlanCacheRelCallback(), ReindexIsProcessingIndex(), relation_has_unique_index_for(), relation_is_updatable(), RelationIsVisibleExt(), RememberConstraintForRebuilding(), RememberIndexForRebuilding(), RememberStatisticsForRebuilding(), roles_list_append(), StatisticsObjIsVisibleExt(), TSConfigIsVisibleExt(), TSDictionaryIsVisibleExt(), TSParserIsVisibleExt(), TSTemplateIsVisibleExt(), typeInheritsFrom(), and TypeIsVisibleExt().

list_member_ptr()

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

Definition at line 682 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, and lfirst.

Referenced by count_common_leading_pathkeys_unordered(), create_bitmap_scan_plan(), create_tidrangescan_plan(), create_tidscan_plan(), estimate_multivariate_bucketsize(), ExecInsert(), get_foreign_key_join_selectivity(), get_useful_pathkeys_for_distinct(), group_keys_reorder_by_pathkeys(), 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 742 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, and lfirst_xid.

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 1703 of file list.c.

{
    Oid         v1 = lfirst_oid(p1);
    Oid         v2 = lfirst_oid(p2);
 
    return pg_cmp_u32(v1, v2);
}

References fb(), lfirst_oid, and pg_cmp_u32().

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

list_sort()

void list_sort	(	List *	list,
		list_sort_comparator	cmp
	)

Definition at line 1674 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(), fb(), len, 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(), UpdateLogicalMappings(), and WalSummariesAreComplete().

list_truncate()

List * list_truncate	(	List *	list,
		int	new_size
	)

Definition at line 631 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 fb(), 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(), transformReturningClause(), transformSetOperationStmt(), and transformWholeRowRef().

list_union()

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

Definition at line 1066 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, fb(), 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 1113 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, fb(), 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 1136 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, fb(), 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 1090 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, fb(), IsPointerList, lappend(), lfirst, list_copy(), and list_member_ptr().

new_head_cell()

static void new_head_cell ( List *  list )

static

Definition at line 305 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 fb().

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

new_list()

static List * new_list ( NodeTag  type, int  min_size  )

static

Definition at line 91 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, fb(), LIST_HEADER_OVERHEAD, Max, palloc(), pg_nextpower2_32(), and 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 323 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().

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