1
0
mirror of https://github.com/postgres/postgres.git synced 2025-08-19 23:22:23 +03:00
Files
postgres/src/fe_utils/simple_list.c
Alvaro Herrera b304b2b65f Fix parallel restore of FKs to partitioned tables
When an FK constraint is created, it needs the index on the referenced
table to exist and be valid.  When doing parallel pg_restore and the
referenced table was partitioned, this condition can sometimes not be
met, because pg_dump didn't emit sufficient object dependencies to
ensure so; this means that parallel pg_restore would fail in certain
conditions.  Fix by having pg_dump make the FK constraint object
dependent on the partition attachment objects for the constraint's
referenced index.

This has been broken since f56f8f8da6, so backpatch to Postgres 12.

Discussion: https://postgr.es/m/20191005224333.GA9738@alvherre.pgsql
2019-10-17 09:58:01 +02:00

138 lines
2.7 KiB
C

/*-------------------------------------------------------------------------
*
* Simple list facilities for frontend code
*
* Data structures for simple lists of OIDs and strings. The support for
* these is very primitive compared to the backend's List facilities, but
* it's all we need in, eg, pg_dump.
*
*
* Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* src/fe_utils/simple_list.c
*
*-------------------------------------------------------------------------
*/
#include "postgres_fe.h"
#include "fe_utils/simple_list.h"
/*
* Append an OID to the list.
*/
void
simple_oid_list_append(SimpleOidList *list, Oid val)
{
SimpleOidListCell *cell;
cell = (SimpleOidListCell *) pg_malloc(sizeof(SimpleOidListCell));
cell->next = NULL;
cell->val = val;
if (list->tail)
list->tail->next = cell;
else
list->head = cell;
list->tail = cell;
}
/*
* Is OID present in the list?
*/
bool
simple_oid_list_member(SimpleOidList *list, Oid val)
{
SimpleOidListCell *cell;
for (cell = list->head; cell; cell = cell->next)
{
if (cell->val == val)
return true;
}
return false;
}
/*
* Append a string to the list.
*
* The given string is copied, so it need not survive past the call.
*/
void
simple_string_list_append(SimpleStringList *list, const char *val)
{
SimpleStringListCell *cell;
cell = (SimpleStringListCell *)
pg_malloc(offsetof(SimpleStringListCell, val) + strlen(val) + 1);
cell->next = NULL;
cell->touched = false;
strcpy(cell->val, val);
if (list->tail)
list->tail->next = cell;
else
list->head = cell;
list->tail = cell;
}
/*
* Is string present in the list?
*
* If found, the "touched" field of the first match is set true.
*/
bool
simple_string_list_member(SimpleStringList *list, const char *val)
{
SimpleStringListCell *cell;
for (cell = list->head; cell; cell = cell->next)
{
if (strcmp(cell->val, val) == 0)
{
cell->touched = true;
return true;
}
}
return false;
}
/*
* Find first not-touched list entry, if there is one.
*/
const char *
simple_string_list_not_touched(SimpleStringList *list)
{
SimpleStringListCell *cell;
for (cell = list->head; cell; cell = cell->next)
{
if (!cell->touched)
return cell->val;
}
return NULL;
}
/*
* Append a pointer to the list.
*
* Caller must ensure that the pointer remains valid.
*/
void
simple_ptr_list_append(SimplePtrList *list, void *ptr)
{
SimplePtrListCell *cell;
cell = (SimplePtrListCell *) pg_malloc(sizeof(SimplePtrListCell));
cell->next = NULL;
cell->ptr = ptr;
if (list->tail)
list->tail->next = cell;
else
list->head = cell;
list->tail = cell;
}