PostgreSQL Source Code  git master
info.c
Go to the documentation of this file.
1 /*
2  * info.c
3  *
4  * information support functions
5  *
6  * Copyright (c) 2010-2024, PostgreSQL Global Development Group
7  * src/bin/pg_upgrade/info.c
8  */
9 
10 #include "postgres_fe.h"
11 
12 #include "access/transam.h"
13 #include "catalog/pg_class_d.h"
14 #include "pg_upgrade.h"
15 #include "pqexpbuffer.h"
16 
17 static void create_rel_filename_map(const char *old_data, const char *new_data,
18  const DbInfo *old_db, const DbInfo *new_db,
19  const RelInfo *old_rel, const RelInfo *new_rel,
20  FileNameMap *map);
21 static void report_unmatched_relation(const RelInfo *rel, const DbInfo *db,
22  bool is_new_db);
23 static void free_db_and_rel_infos(DbInfoArr *db_arr);
25 static void get_db_infos(ClusterInfo *cluster);
26 static char *get_rel_infos_query(void);
27 static void process_rel_infos(DbInfo *dbinfo, PGresult *res, void *arg);
28 static void free_rel_infos(RelInfoArr *rel_arr);
29 static void print_db_infos(DbInfoArr *db_arr);
30 static void print_rel_infos(RelInfoArr *rel_arr);
31 static void print_slot_infos(LogicalSlotInfoArr *slot_arr);
34 
35 
36 /*
37  * gen_db_file_maps()
38  *
39  * generates a database mapping from "old_db" to "new_db".
40  *
41  * Returns a malloc'ed array of mappings. The length of the array
42  * is returned into *nmaps.
43  */
45 gen_db_file_maps(DbInfo *old_db, DbInfo *new_db,
46  int *nmaps,
47  const char *old_pgdata, const char *new_pgdata)
48 {
50  int old_relnum,
51  new_relnum;
52  int num_maps = 0;
53  bool all_matched = true;
54 
55  /* There will certainly not be more mappings than there are old rels */
56  maps = (FileNameMap *) pg_malloc(sizeof(FileNameMap) *
57  old_db->rel_arr.nrels);
58 
59  /*
60  * Each of the RelInfo arrays should be sorted by OID. Scan through them
61  * and match them up. If we fail to match everything, we'll abort, but
62  * first print as much info as we can about mismatches.
63  */
64  old_relnum = new_relnum = 0;
65  while (old_relnum < old_db->rel_arr.nrels ||
66  new_relnum < new_db->rel_arr.nrels)
67  {
68  RelInfo *old_rel = (old_relnum < old_db->rel_arr.nrels) ?
69  &old_db->rel_arr.rels[old_relnum] : NULL;
70  RelInfo *new_rel = (new_relnum < new_db->rel_arr.nrels) ?
71  &new_db->rel_arr.rels[new_relnum] : NULL;
72 
73  /* handle running off one array before the other */
74  if (!new_rel)
75  {
76  /*
77  * old_rel is unmatched. This should never happen, because we
78  * force new rels to have TOAST tables if the old one did.
79  */
80  report_unmatched_relation(old_rel, old_db, false);
81  all_matched = false;
82  old_relnum++;
83  continue;
84  }
85  if (!old_rel)
86  {
87  /*
88  * new_rel is unmatched. This shouldn't really happen either, but
89  * if it's a TOAST table, we can ignore it and continue
90  * processing, assuming that the new server made a TOAST table
91  * that wasn't needed.
92  */
93  if (strcmp(new_rel->nspname, "pg_toast") != 0)
94  {
95  report_unmatched_relation(new_rel, new_db, true);
96  all_matched = false;
97  }
98  new_relnum++;
99  continue;
100  }
101 
102  /* check for mismatched OID */
103  if (old_rel->reloid < new_rel->reloid)
104  {
105  /* old_rel is unmatched, see comment above */
106  report_unmatched_relation(old_rel, old_db, false);
107  all_matched = false;
108  old_relnum++;
109  continue;
110  }
111  else if (old_rel->reloid > new_rel->reloid)
112  {
113  /* new_rel is unmatched, see comment above */
114  if (strcmp(new_rel->nspname, "pg_toast") != 0)
115  {
116  report_unmatched_relation(new_rel, new_db, true);
117  all_matched = false;
118  }
119  new_relnum++;
120  continue;
121  }
122 
123  /*
124  * Verify that rels of same OID have same name. The namespace name
125  * should always match, but the relname might not match for TOAST
126  * tables (and, therefore, their indexes).
127  */
128  if (strcmp(old_rel->nspname, new_rel->nspname) != 0 ||
129  strcmp(old_rel->relname, new_rel->relname) != 0)
130  {
131  pg_log(PG_WARNING, "Relation names for OID %u in database \"%s\" do not match: "
132  "old name \"%s.%s\", new name \"%s.%s\"",
133  old_rel->reloid, old_db->db_name,
134  old_rel->nspname, old_rel->relname,
135  new_rel->nspname, new_rel->relname);
136  all_matched = false;
137  old_relnum++;
138  new_relnum++;
139  continue;
140  }
141 
142  /* OK, create a mapping entry */
143  create_rel_filename_map(old_pgdata, new_pgdata, old_db, new_db,
144  old_rel, new_rel, maps + num_maps);
145  num_maps++;
146  old_relnum++;
147  new_relnum++;
148  }
149 
150  if (!all_matched)
151  pg_fatal("Failed to match up old and new tables in database \"%s\"",
152  old_db->db_name);
153 
154  *nmaps = num_maps;
155  return maps;
156 }
157 
158 
159 /*
160  * create_rel_filename_map()
161  *
162  * fills a file node map structure and returns it in "map".
163  */
164 static void
165 create_rel_filename_map(const char *old_data, const char *new_data,
166  const DbInfo *old_db, const DbInfo *new_db,
167  const RelInfo *old_rel, const RelInfo *new_rel,
168  FileNameMap *map)
169 {
170  /* In case old/new tablespaces don't match, do them separately. */
171  if (strlen(old_rel->tablespace) == 0)
172  {
173  /*
174  * relation belongs to the default tablespace, hence relfiles should
175  * exist in the data directories.
176  */
177  map->old_tablespace = old_data;
178  map->old_tablespace_suffix = "/base";
179  }
180  else
181  {
182  /* relation belongs to a tablespace, so use the tablespace location */
183  map->old_tablespace = old_rel->tablespace;
185  }
186 
187  /* Do the same for new tablespaces */
188  if (strlen(new_rel->tablespace) == 0)
189  {
190  map->new_tablespace = new_data;
191  map->new_tablespace_suffix = "/base";
192  }
193  else
194  {
195  map->new_tablespace = new_rel->tablespace;
197  }
198 
199  /* DB oid and relfilenumbers are preserved between old and new cluster */
200  map->db_oid = old_db->db_oid;
201  map->relfilenumber = old_rel->relfilenumber;
202 
203  /* used only for logging and error reporting, old/new are identical */
204  map->nspname = old_rel->nspname;
205  map->relname = old_rel->relname;
206 }
207 
208 
209 /*
210  * Complain about a relation we couldn't match to the other database,
211  * identifying it as best we can.
212  */
213 static void
214 report_unmatched_relation(const RelInfo *rel, const DbInfo *db, bool is_new_db)
215 {
216  Oid reloid = rel->reloid; /* we might change rel below */
217  char reldesc[1000];
218  int i;
219 
220  snprintf(reldesc, sizeof(reldesc), "\"%s.%s\"",
221  rel->nspname, rel->relname);
222  if (rel->indtable)
223  {
224  for (i = 0; i < db->rel_arr.nrels; i++)
225  {
226  const RelInfo *hrel = &db->rel_arr.rels[i];
227 
228  if (hrel->reloid == rel->indtable)
229  {
230  snprintf(reldesc + strlen(reldesc),
231  sizeof(reldesc) - strlen(reldesc),
232  _(" which is an index on \"%s.%s\""),
233  hrel->nspname, hrel->relname);
234  /* Shift attention to index's table for toast check */
235  rel = hrel;
236  break;
237  }
238  }
239  if (i >= db->rel_arr.nrels)
240  snprintf(reldesc + strlen(reldesc),
241  sizeof(reldesc) - strlen(reldesc),
242  _(" which is an index on OID %u"), rel->indtable);
243  }
244  if (rel->toastheap)
245  {
246  for (i = 0; i < db->rel_arr.nrels; i++)
247  {
248  const RelInfo *brel = &db->rel_arr.rels[i];
249 
250  if (brel->reloid == rel->toastheap)
251  {
252  snprintf(reldesc + strlen(reldesc),
253  sizeof(reldesc) - strlen(reldesc),
254  _(" which is the TOAST table for \"%s.%s\""),
255  brel->nspname, brel->relname);
256  break;
257  }
258  }
259  if (i >= db->rel_arr.nrels)
260  snprintf(reldesc + strlen(reldesc),
261  sizeof(reldesc) - strlen(reldesc),
262  _(" which is the TOAST table for OID %u"), rel->toastheap);
263  }
264 
265  if (is_new_db)
266  pg_log(PG_WARNING, "No match found in old cluster for new relation with OID %u in database \"%s\": %s",
267  reloid, db->db_name, reldesc);
268  else
269  pg_log(PG_WARNING, "No match found in new cluster for old relation with OID %u in database \"%s\": %s",
270  reloid, db->db_name, reldesc);
271 }
272 
273 /*
274  * get_db_rel_and_slot_infos()
275  *
276  * higher level routine to generate dbinfos for the database running
277  * on the given "port". Assumes that server is already running.
278  */
279 void
281 {
283  char *rel_infos_query = NULL;
284  char *logical_slot_infos_query = NULL;
285 
286  if (cluster->dbarr.dbs != NULL)
288 
291 
292  rel_infos_query = get_rel_infos_query();
294  rel_infos_query,
296  true, NULL);
297 
298  /*
299  * Logical slots are only carried over to the new cluster when the old
300  * cluster is on PG17 or newer. This is because before that the logical
301  * slots are not saved at shutdown, so there is no guarantee that the
302  * latest confirmed_flush_lsn is saved to disk which can lead to data
303  * loss. It is still not guaranteed for manually created slots in PG17, so
304  * subsequent checks done in check_old_cluster_for_valid_slots() would
305  * raise a FATAL error if such slots are included.
306  */
307  if (cluster == &old_cluster &&
308  GET_MAJOR_VERSION(cluster->major_version) > 1600)
309  {
310  logical_slot_infos_query = get_old_cluster_logical_slot_infos_query();
312  logical_slot_infos_query,
314  true, NULL);
315  }
316 
317  upgrade_task_run(task, cluster);
318  upgrade_task_free(task);
319 
320  pg_free(rel_infos_query);
321  if (logical_slot_infos_query)
322  pg_free(logical_slot_infos_query);
323 
324  if (cluster == &old_cluster)
325  pg_log(PG_VERBOSE, "\nsource databases:");
326  else
327  pg_log(PG_VERBOSE, "\ntarget databases:");
328 
329  if (log_opts.verbose)
330  print_db_infos(&cluster->dbarr);
331 }
332 
333 
334 /*
335  * Get information about template0, which will be copied from the old cluster
336  * to the new cluster.
337  */
338 static void
340 {
341  PGconn *conn = connectToServer(cluster, "template1");
343  PGresult *dbres;
344  int i_datencoding;
345  int i_datlocprovider;
346  int i_datcollate;
347  int i_datctype;
348  int i_datlocale;
349 
350  if (GET_MAJOR_VERSION(cluster->major_version) >= 1700)
351  dbres = executeQueryOrDie(conn,
352  "SELECT encoding, datlocprovider, "
353  " datcollate, datctype, datlocale "
354  "FROM pg_catalog.pg_database "
355  "WHERE datname='template0'");
356  else if (GET_MAJOR_VERSION(cluster->major_version) >= 1500)
357  dbres = executeQueryOrDie(conn,
358  "SELECT encoding, datlocprovider, "
359  " datcollate, datctype, daticulocale AS datlocale "
360  "FROM pg_catalog.pg_database "
361  "WHERE datname='template0'");
362  else
363  dbres = executeQueryOrDie(conn,
364  "SELECT encoding, 'c' AS datlocprovider, "
365  " datcollate, datctype, NULL AS datlocale "
366  "FROM pg_catalog.pg_database "
367  "WHERE datname='template0'");
368 
369 
370  if (PQntuples(dbres) != 1)
371  pg_fatal("template0 not found");
372 
373  locale = pg_malloc(sizeof(DbLocaleInfo));
374 
375  i_datencoding = PQfnumber(dbres, "encoding");
376  i_datlocprovider = PQfnumber(dbres, "datlocprovider");
377  i_datcollate = PQfnumber(dbres, "datcollate");
378  i_datctype = PQfnumber(dbres, "datctype");
379  i_datlocale = PQfnumber(dbres, "datlocale");
380 
381  locale->db_encoding = atoi(PQgetvalue(dbres, 0, i_datencoding));
382  locale->db_collprovider = PQgetvalue(dbres, 0, i_datlocprovider)[0];
383  locale->db_collate = pg_strdup(PQgetvalue(dbres, 0, i_datcollate));
384  locale->db_ctype = pg_strdup(PQgetvalue(dbres, 0, i_datctype));
385  if (PQgetisnull(dbres, 0, i_datlocale))
386  locale->db_locale = NULL;
387  else
388  locale->db_locale = pg_strdup(PQgetvalue(dbres, 0, i_datlocale));
389 
390  cluster->template0 = locale;
391 
392  PQclear(dbres);
393  PQfinish(conn);
394 }
395 
396 
397 /*
398  * get_db_infos()
399  *
400  * Scans pg_database system catalog and populates all user
401  * databases.
402  */
403 static void
405 {
406  PGconn *conn = connectToServer(cluster, "template1");
407  PGresult *res;
408  int ntups;
409  int tupnum;
410  DbInfo *dbinfos;
411  int i_datname,
412  i_oid,
413  i_spclocation;
414  char query[QUERY_ALLOC];
415 
416  snprintf(query, sizeof(query),
417  "SELECT d.oid, d.datname, d.encoding, d.datcollate, d.datctype, ");
418  if (GET_MAJOR_VERSION(cluster->major_version) >= 1700)
419  snprintf(query + strlen(query), sizeof(query) - strlen(query),
420  "datlocprovider, datlocale, ");
421  else if (GET_MAJOR_VERSION(cluster->major_version) >= 1500)
422  snprintf(query + strlen(query), sizeof(query) - strlen(query),
423  "datlocprovider, daticulocale AS datlocale, ");
424  else
425  snprintf(query + strlen(query), sizeof(query) - strlen(query),
426  "'c' AS datlocprovider, NULL AS datlocale, ");
427  snprintf(query + strlen(query), sizeof(query) - strlen(query),
428  "pg_catalog.pg_tablespace_location(t.oid) AS spclocation "
429  "FROM pg_catalog.pg_database d "
430  " LEFT OUTER JOIN pg_catalog.pg_tablespace t "
431  " ON d.dattablespace = t.oid "
432  "WHERE d.datallowconn = true "
433  "ORDER BY 1");
434 
435  res = executeQueryOrDie(conn, "%s", query);
436 
437  i_oid = PQfnumber(res, "oid");
438  i_datname = PQfnumber(res, "datname");
439  i_spclocation = PQfnumber(res, "spclocation");
440 
441  ntups = PQntuples(res);
442  dbinfos = (DbInfo *) pg_malloc0(sizeof(DbInfo) * ntups);
443 
444  for (tupnum = 0; tupnum < ntups; tupnum++)
445  {
446  dbinfos[tupnum].db_oid = atooid(PQgetvalue(res, tupnum, i_oid));
447  dbinfos[tupnum].db_name = pg_strdup(PQgetvalue(res, tupnum, i_datname));
448  snprintf(dbinfos[tupnum].db_tablespace, sizeof(dbinfos[tupnum].db_tablespace), "%s",
449  PQgetvalue(res, tupnum, i_spclocation));
450  }
451  PQclear(res);
452 
453  PQfinish(conn);
454 
455  cluster->dbarr.dbs = dbinfos;
456  cluster->dbarr.ndbs = ntups;
457 }
458 
459 
460 /*
461  * get_rel_infos_query()
462  *
463  * Returns the query for retrieving the relation information for all the user
464  * tables and indexes in the database, for use by get_db_rel_and_slot_infos()'s
465  * UpgradeTask.
466  *
467  * Note: the result is assumed to be sorted by OID. This allows later
468  * processing to match up old and new databases efficiently.
469  */
470 static char *
472 {
473  PQExpBufferData query;
474 
475  initPQExpBuffer(&query);
476 
477  /*
478  * Create a CTE that collects OIDs of regular user tables and matviews,
479  * but excluding toast tables and indexes. We assume that relations with
480  * OIDs >= FirstNormalObjectId belong to the user. (That's probably
481  * redundant with the namespace-name exclusions, but let's be safe.)
482  *
483  * pg_largeobject contains user data that does not appear in pg_dump
484  * output, so we have to copy that system table. It's easiest to do that
485  * by treating it as a user table.
486  */
487  appendPQExpBuffer(&query,
488  "WITH regular_heap (reloid, indtable, toastheap) AS ( "
489  " SELECT c.oid, 0::oid, 0::oid "
490  " FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n "
491  " ON c.relnamespace = n.oid "
492  " WHERE relkind IN (" CppAsString2(RELKIND_RELATION) ", "
493  CppAsString2(RELKIND_MATVIEW) ") AND "
494  /* exclude possible orphaned temp tables */
495  " ((n.nspname !~ '^pg_temp_' AND "
496  " n.nspname !~ '^pg_toast_temp_' AND "
497  " n.nspname NOT IN ('pg_catalog', 'information_schema', "
498  " 'binary_upgrade', 'pg_toast') AND "
499  " c.oid >= %u::pg_catalog.oid) OR "
500  " (n.nspname = 'pg_catalog' AND "
501  " relname IN ('pg_largeobject') ))), ",
503 
504  /*
505  * Add a CTE that collects OIDs of toast tables belonging to the tables
506  * selected by the regular_heap CTE. (We have to do this separately
507  * because the namespace-name rules above don't work for toast tables.)
508  */
509  appendPQExpBufferStr(&query,
510  " toast_heap (reloid, indtable, toastheap) AS ( "
511  " SELECT c.reltoastrelid, 0::oid, c.oid "
512  " FROM regular_heap JOIN pg_catalog.pg_class c "
513  " ON regular_heap.reloid = c.oid "
514  " WHERE c.reltoastrelid != 0), ");
515 
516  /*
517  * Add a CTE that collects OIDs of all valid indexes on the previously
518  * selected tables. We can ignore invalid indexes since pg_dump does.
519  * Testing indisready is necessary in 9.2, and harmless in earlier/later
520  * versions.
521  */
522  appendPQExpBufferStr(&query,
523  " all_index (reloid, indtable, toastheap) AS ( "
524  " SELECT indexrelid, indrelid, 0::oid "
525  " FROM pg_catalog.pg_index "
526  " WHERE indisvalid AND indisready "
527  " AND indrelid IN "
528  " (SELECT reloid FROM regular_heap "
529  " UNION ALL "
530  " SELECT reloid FROM toast_heap)) ");
531 
532  /*
533  * And now we can write the query that retrieves the data we want for each
534  * heap and index relation. Make sure result is sorted by OID.
535  */
536  appendPQExpBufferStr(&query,
537  "SELECT all_rels.*, n.nspname, c.relname, "
538  " c.relfilenode, c.reltablespace, "
539  " pg_catalog.pg_tablespace_location(t.oid) AS spclocation "
540  "FROM (SELECT * FROM regular_heap "
541  " UNION ALL "
542  " SELECT * FROM toast_heap "
543  " UNION ALL "
544  " SELECT * FROM all_index) all_rels "
545  " JOIN pg_catalog.pg_class c "
546  " ON all_rels.reloid = c.oid "
547  " JOIN pg_catalog.pg_namespace n "
548  " ON c.relnamespace = n.oid "
549  " LEFT OUTER JOIN pg_catalog.pg_tablespace t "
550  " ON c.reltablespace = t.oid "
551  "ORDER BY 1");
552 
553  return query.data;
554 }
555 
556 /*
557  * Callback function for processing results of the query returned by
558  * get_rel_infos_query(), which is used for get_db_rel_and_slot_infos()'s
559  * UpgradeTask. This function stores the relation information for later use.
560  */
561 static void
563 {
564  int ntups = PQntuples(res);
565  RelInfo *relinfos = (RelInfo *) pg_malloc(sizeof(RelInfo) * ntups);
566  int i_reloid = PQfnumber(res, "reloid");
567  int i_indtable = PQfnumber(res, "indtable");
568  int i_toastheap = PQfnumber(res, "toastheap");
569  int i_nspname = PQfnumber(res, "nspname");
570  int i_relname = PQfnumber(res, "relname");
571  int i_relfilenumber = PQfnumber(res, "relfilenode");
572  int i_reltablespace = PQfnumber(res, "reltablespace");
573  int i_spclocation = PQfnumber(res, "spclocation");
574  int num_rels = 0;
575  char *nspname = NULL;
576  char *relname = NULL;
577  char *tablespace = NULL;
578  char *last_namespace = NULL;
579  char *last_tablespace = NULL;
580 
582 
583  for (int relnum = 0; relnum < ntups; relnum++)
584  {
585  RelInfo *curr = &relinfos[num_rels++];
586 
587  curr->reloid = atooid(PQgetvalue(res, relnum, i_reloid));
588  curr->indtable = atooid(PQgetvalue(res, relnum, i_indtable));
589  curr->toastheap = atooid(PQgetvalue(res, relnum, i_toastheap));
590 
591  nspname = PQgetvalue(res, relnum, i_nspname);
592  curr->nsp_alloc = false;
593 
594  /*
595  * Many of the namespace and tablespace strings are identical, so we
596  * try to reuse the allocated string pointers where possible to reduce
597  * memory consumption.
598  */
599  /* Can we reuse the previous string allocation? */
600  if (last_namespace && strcmp(nspname, last_namespace) == 0)
601  curr->nspname = last_namespace;
602  else
603  {
604  last_namespace = curr->nspname = pg_strdup(nspname);
605  curr->nsp_alloc = true;
606  }
607 
608  relname = PQgetvalue(res, relnum, i_relname);
609  curr->relname = pg_strdup(relname);
610 
611  curr->relfilenumber = atooid(PQgetvalue(res, relnum, i_relfilenumber));
612  curr->tblsp_alloc = false;
613 
614  /* Is the tablespace oid non-default? */
615  if (atooid(PQgetvalue(res, relnum, i_reltablespace)) != 0)
616  {
617  /*
618  * The tablespace location might be "", meaning the cluster
619  * default location, i.e. pg_default or pg_global.
620  */
621  tablespace = PQgetvalue(res, relnum, i_spclocation);
622 
623  /* Can we reuse the previous string allocation? */
624  if (last_tablespace && strcmp(tablespace, last_tablespace) == 0)
625  curr->tablespace = last_tablespace;
626  else
627  {
628  last_tablespace = curr->tablespace = pg_strdup(tablespace);
629  curr->tblsp_alloc = true;
630  }
631  }
632  else
633  /* A zero reltablespace oid indicates the database tablespace. */
634  curr->tablespace = dbinfo->db_tablespace;
635  }
636 
637  dbinfo->rel_arr.rels = relinfos;
638  dbinfo->rel_arr.nrels = num_rels;
639 }
640 
641 /*
642  * get_old_cluster_logical_slot_infos_query()
643  *
644  * Returns the query for retrieving the logical slot information for all the
645  * logical replication slots in the database, for use by
646  * get_db_rel_and_slot_infos()'s UpgradeTask. The status of each logical slot
647  * is checked in check_old_cluster_for_valid_slots().
648  */
649 static char *
651 {
652  /*
653  * Fetch the logical replication slot information. The check whether the
654  * slot is considered caught up is done by an upgrade function. This
655  * regards the slot as caught up if we don't find any decodable changes.
656  * See binary_upgrade_logical_slot_has_caught_up().
657  *
658  * Note that we can't ensure whether the slot is caught up during
659  * live_check as the new WAL records could be generated.
660  *
661  * We intentionally skip checking the WALs for invalidated slots as the
662  * corresponding WALs could have been removed for such slots.
663  *
664  * The temporary slots are explicitly ignored while checking because such
665  * slots cannot exist after the upgrade. During the upgrade, clusters are
666  * started and stopped several times causing any temporary slots to be
667  * removed.
668  */
669  return psprintf("SELECT slot_name, plugin, two_phase, failover, "
670  "%s as caught_up, invalidation_reason IS NOT NULL as invalid "
671  "FROM pg_catalog.pg_replication_slots "
672  "WHERE slot_type = 'logical' AND "
673  "database = current_database() AND "
674  "temporary IS FALSE;",
675  user_opts.live_check ? "FALSE" :
676  "(CASE WHEN invalidation_reason IS NOT NULL THEN FALSE "
677  "ELSE (SELECT pg_catalog.binary_upgrade_logical_slot_has_caught_up(slot_name)) "
678  "END)");
679 }
680 
681 /*
682  * Callback function for processing results of the query returned by
683  * get_old_cluster_logical_slot_infos_query(), which is used for
684  * get_db_rel_and_slot_infos()'s UpgradeTask. This function stores the logical
685  * slot information for later use.
686  */
687 static void
689 {
690  LogicalSlotInfo *slotinfos = NULL;
691  int num_slots = PQntuples(res);
692 
695 
696  if (num_slots)
697  {
698  int i_slotname;
699  int i_plugin;
700  int i_twophase;
701  int i_failover;
702  int i_caught_up;
703  int i_invalid;
704 
705  slotinfos = (LogicalSlotInfo *) pg_malloc(sizeof(LogicalSlotInfo) * num_slots);
706 
707  i_slotname = PQfnumber(res, "slot_name");
708  i_plugin = PQfnumber(res, "plugin");
709  i_twophase = PQfnumber(res, "two_phase");
710  i_failover = PQfnumber(res, "failover");
711  i_caught_up = PQfnumber(res, "caught_up");
712  i_invalid = PQfnumber(res, "invalid");
713 
714  for (int slotnum = 0; slotnum < num_slots; slotnum++)
715  {
716  LogicalSlotInfo *curr = &slotinfos[slotnum];
717 
718  curr->slotname = pg_strdup(PQgetvalue(res, slotnum, i_slotname));
719  curr->plugin = pg_strdup(PQgetvalue(res, slotnum, i_plugin));
720  curr->two_phase = (strcmp(PQgetvalue(res, slotnum, i_twophase), "t") == 0);
721  curr->failover = (strcmp(PQgetvalue(res, slotnum, i_failover), "t") == 0);
722  curr->caught_up = (strcmp(PQgetvalue(res, slotnum, i_caught_up), "t") == 0);
723  curr->invalid = (strcmp(PQgetvalue(res, slotnum, i_invalid), "t") == 0);
724  }
725  }
726 
727  dbinfo->slot_arr.slots = slotinfos;
728  dbinfo->slot_arr.nslots = num_slots;
729 }
730 
731 
732 /*
733  * count_old_cluster_logical_slots()
734  *
735  * Returns the number of logical replication slots for all databases.
736  *
737  * Note: this function always returns 0 if the old_cluster is PG16 and prior
738  * because we gather slot information only for cluster versions greater than or
739  * equal to PG17. See get_old_cluster_logical_slot_infos().
740  */
741 int
743 {
744  int slot_count = 0;
745 
746  for (int dbnum = 0; dbnum < old_cluster.dbarr.ndbs; dbnum++)
747  slot_count += old_cluster.dbarr.dbs[dbnum].slot_arr.nslots;
748 
749  return slot_count;
750 }
751 
752 /*
753  * get_subscription_count()
754  *
755  * Gets the number of subscriptions in the cluster.
756  */
757 void
759 {
760  PGconn *conn;
761  PGresult *res;
762 
763  conn = connectToServer(cluster, "template1");
764  res = executeQueryOrDie(conn, "SELECT count(*) "
765  "FROM pg_catalog.pg_subscription");
766  cluster->nsubs = atoi(PQgetvalue(res, 0, 0));
767 
768  PQclear(res);
769  PQfinish(conn);
770 }
771 
772 static void
774 {
775  int dbnum;
776 
777  for (dbnum = 0; dbnum < db_arr->ndbs; dbnum++)
778  {
779  free_rel_infos(&db_arr->dbs[dbnum].rel_arr);
780  pg_free(db_arr->dbs[dbnum].db_name);
781  }
782  pg_free(db_arr->dbs);
783  db_arr->dbs = NULL;
784  db_arr->ndbs = 0;
785 }
786 
787 
788 static void
790 {
791  int relnum;
792 
793  for (relnum = 0; relnum < rel_arr->nrels; relnum++)
794  {
795  if (rel_arr->rels[relnum].nsp_alloc)
796  pg_free(rel_arr->rels[relnum].nspname);
797  pg_free(rel_arr->rels[relnum].relname);
798  if (rel_arr->rels[relnum].tblsp_alloc)
799  pg_free(rel_arr->rels[relnum].tablespace);
800  }
801  pg_free(rel_arr->rels);
802  rel_arr->nrels = 0;
803 }
804 
805 
806 static void
808 {
809  int dbnum;
810 
811  for (dbnum = 0; dbnum < db_arr->ndbs; dbnum++)
812  {
813  DbInfo *pDbInfo = &db_arr->dbs[dbnum];
814 
815  pg_log(PG_VERBOSE, "Database: \"%s\"", pDbInfo->db_name);
816  print_rel_infos(&pDbInfo->rel_arr);
817  print_slot_infos(&pDbInfo->slot_arr);
818  }
819 }
820 
821 
822 static void
824 {
825  int relnum;
826 
827  for (relnum = 0; relnum < rel_arr->nrels; relnum++)
828  pg_log(PG_VERBOSE, "relname: \"%s.%s\", reloid: %u, reltblspace: \"%s\"",
829  rel_arr->rels[relnum].nspname,
830  rel_arr->rels[relnum].relname,
831  rel_arr->rels[relnum].reloid,
832  rel_arr->rels[relnum].tablespace);
833 }
834 
835 static void
837 {
838  /* Quick return if there are no logical slots. */
839  if (slot_arr->nslots == 0)
840  return;
841 
842  pg_log(PG_VERBOSE, "Logical replication slots in the database:");
843 
844  for (int slotnum = 0; slotnum < slot_arr->nslots; slotnum++)
845  {
846  LogicalSlotInfo *slot_info = &slot_arr->slots[slotnum];
847 
848  pg_log(PG_VERBOSE, "slot name: \"%s\", output plugin: \"%s\", two_phase: %s",
849  slot_info->slotname,
850  slot_info->plugin,
851  slot_info->two_phase ? "true" : "false");
852  }
853 }
#define AssertVariableIsOfType(varname, typename)
Definition: c.h:972
#define CppAsString2(x)
Definition: c.h:330
void cluster(ParseState *pstate, ClusterStmt *stmt, bool isTopLevel)
Definition: cluster.c:107
#define _(x)
Definition: elog.c:90
void PQfinish(PGconn *conn)
Definition: fe-connect.c:4893
int PQntuples(const PGresult *res)
Definition: fe-exec.c:3481
char * PQgetvalue(const PGresult *res, int tup_num, int field_num)
Definition: fe-exec.c:3876
int PQfnumber(const PGresult *res, const char *field_name)
Definition: fe-exec.c:3589
int PQgetisnull(const PGresult *res, int tup_num, int field_num)
Definition: fe-exec.c:3901
void * pg_malloc0(size_t size)
Definition: fe_memutils.c:53
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
void pg_free(void *ptr)
Definition: fe_memutils.c:105
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
static void print_slot_infos(LogicalSlotInfoArr *slot_arr)
Definition: info.c:836
void get_subscription_count(ClusterInfo *cluster)
Definition: info.c:758
static void process_rel_infos(DbInfo *dbinfo, PGresult *res, void *arg)
Definition: info.c:562
static void get_template0_info(ClusterInfo *cluster)
Definition: info.c:339
static void report_unmatched_relation(const RelInfo *rel, const DbInfo *db, bool is_new_db)
Definition: info.c:214
static void get_db_infos(ClusterInfo *cluster)
Definition: info.c:404
static void free_rel_infos(RelInfoArr *rel_arr)
Definition: info.c:789
static void print_rel_infos(RelInfoArr *rel_arr)
Definition: info.c:823
static void create_rel_filename_map(const char *old_data, const char *new_data, const DbInfo *old_db, const DbInfo *new_db, const RelInfo *old_rel, const RelInfo *new_rel, FileNameMap *map)
Definition: info.c:165
FileNameMap * gen_db_file_maps(DbInfo *old_db, DbInfo *new_db, int *nmaps, const char *old_pgdata, const char *new_pgdata)
Definition: info.c:45
static void free_db_and_rel_infos(DbInfoArr *db_arr)
Definition: info.c:773
static char * get_rel_infos_query(void)
Definition: info.c:471
static void process_old_cluster_logical_slot_infos(DbInfo *dbinfo, PGresult *res, void *arg)
Definition: info.c:688
static void print_db_infos(DbInfoArr *db_arr)
Definition: info.c:807
static char * get_old_cluster_logical_slot_infos_query(void)
Definition: info.c:650
int count_old_cluster_logical_slots(void)
Definition: info.c:742
void get_db_rel_and_slot_infos(ClusterInfo *cluster)
Definition: info.c:280
static char * locale
Definition: initdb.c:140
int i
Definition: isn.c:72
void * arg
#define pg_fatal(...)
NameData relname
Definition: pg_class.h:38
static struct LogicalRepInfo * dbinfo
ClusterInfo new_cluster
Definition: pg_upgrade.c:68
ClusterInfo old_cluster
Definition: pg_upgrade.c:67
UpgradeTask * upgrade_task_create(void)
Definition: task.c:117
void upgrade_task_run(const UpgradeTask *task, const ClusterInfo *cluster)
Definition: task.c:420
#define QUERY_ALLOC
Definition: pg_upgrade.h:23
void void pg_log(eLogType type, const char *fmt,...) pg_attribute_printf(2
LogOpts log_opts
Definition: util.c:17
void upgrade_task_free(UpgradeTask *task)
Definition: task.c:133
void(* UpgradeTaskProcessCB)(DbInfo *dbinfo, PGresult *res, void *arg)
Definition: pg_upgrade.h:500
@ PG_WARNING
Definition: pg_upgrade.h:270
@ PG_VERBOSE
Definition: pg_upgrade.h:266
PGconn * connectToServer(ClusterInfo *cluster, const char *db_name)
Definition: server.c:28
#define GET_MAJOR_VERSION(v)
Definition: pg_upgrade.h:27
void upgrade_task_add_step(UpgradeTask *task, const char *query, UpgradeTaskProcessCB process_cb, bool free_result, void *arg)
Definition: task.c:151
PGresult * executeQueryOrDie(PGconn *conn, const char *fmt,...) pg_attribute_printf(2
static char * tablespace
Definition: pgbench.c:216
#define snprintf
Definition: port.h:238
unsigned int Oid
Definition: postgres_ext.h:31
#define atooid(x)
Definition: postgres_ext.h:42
void initPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:90
void appendPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:265
void appendPQExpBufferStr(PQExpBuffer str, const char *data)
Definition: pqexpbuffer.c:367
char * psprintf(const char *fmt,...)
Definition: psprintf.c:43
UserOpts user_opts
Definition: option.c:30
PGconn * conn
Definition: streamutil.c:55
DbInfoArr dbarr
Definition: pg_upgrade.h:284
const char * tablespace_suffix
Definition: pg_upgrade.h:296
DbInfo * dbs
Definition: pg_upgrade.h:215
LogicalSlotInfoArr slot_arr
Definition: pg_upgrade.h:198
char * db_name
Definition: pg_upgrade.h:194
RelInfoArr rel_arr
Definition: pg_upgrade.h:197
Oid db_oid
Definition: pg_upgrade.h:193
const char * new_tablespace
Definition: pg_upgrade.h:178
const char * old_tablespace_suffix
Definition: pg_upgrade.h:179
const char * old_tablespace
Definition: pg_upgrade.h:177
RelFileNumber relfilenumber
Definition: pg_upgrade.h:182
char * relname
Definition: pg_upgrade.h:185
char * nspname
Definition: pg_upgrade.h:184
const char * new_tablespace_suffix
Definition: pg_upgrade.h:180
bool verbose
Definition: pg_upgrade.h:307
LogicalSlotInfo * slots
Definition: pg_upgrade.h:169
RelInfo * rels
Definition: pg_upgrade.h:148
RelFileNumber relfilenumber
Definition: pg_upgrade.h:138
Oid toastheap
Definition: pg_upgrade.h:140
bool tblsp_alloc
Definition: pg_upgrade.h:143
Oid reloid
Definition: pg_upgrade.h:137
char * nspname
Definition: pg_upgrade.h:135
char * tablespace
Definition: pg_upgrade.h:141
Oid indtable
Definition: pg_upgrade.h:139
bool nsp_alloc
Definition: pg_upgrade.h:142
char * relname
Definition: pg_upgrade.h:136
bool live_check
Definition: pg_upgrade.h:324
#define FirstNormalObjectId
Definition: transam.h:197
static const pg_conv_map maps[]