Line data Source code
1 : /*
2 : * info.c
3 : *
4 : * information support functions
5 : *
6 : * Copyright (c) 2010-2026, 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);
24 : static void get_template0_info(ClusterInfo *cluster);
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);
32 : static char *get_old_cluster_logical_slot_infos_query(void);
33 : static void process_old_cluster_logical_slot_infos(DbInfo *dbinfo, PGresult *res, void *arg);
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 : */
44 : FileNameMap *
45 0 : gen_db_file_maps(DbInfo *old_db, DbInfo *new_db,
46 : int *nmaps,
47 : const char *old_pgdata, const char *new_pgdata)
48 : {
49 0 : FileNameMap *maps;
50 0 : int old_relnum,
51 : new_relnum;
52 0 : int num_maps = 0;
53 0 : bool all_matched = true;
54 :
55 : /* There will certainly not be more mappings than there are old rels */
56 0 : maps = (FileNameMap *) pg_malloc(sizeof(FileNameMap) *
57 0 : 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 0 : old_relnum = new_relnum = 0;
65 0 : while (old_relnum < old_db->rel_arr.nrels ||
66 0 : new_relnum < new_db->rel_arr.nrels)
67 : {
68 0 : RelInfo *old_rel = (old_relnum < old_db->rel_arr.nrels) ?
69 0 : &old_db->rel_arr.rels[old_relnum] : NULL;
70 0 : RelInfo *new_rel = (new_relnum < new_db->rel_arr.nrels) ?
71 0 : &new_db->rel_arr.rels[new_relnum] : NULL;
72 :
73 : /* handle running off one array before the other */
74 0 : 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 0 : report_unmatched_relation(old_rel, old_db, false);
81 0 : all_matched = false;
82 0 : old_relnum++;
83 0 : continue;
84 : }
85 0 : 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 0 : if (strcmp(new_rel->nspname, "pg_toast") != 0)
94 : {
95 0 : report_unmatched_relation(new_rel, new_db, true);
96 0 : all_matched = false;
97 0 : }
98 0 : new_relnum++;
99 0 : continue;
100 : }
101 :
102 : /* check for mismatched OID */
103 0 : if (old_rel->reloid < new_rel->reloid)
104 : {
105 : /* old_rel is unmatched, see comment above */
106 0 : report_unmatched_relation(old_rel, old_db, false);
107 0 : all_matched = false;
108 0 : old_relnum++;
109 0 : continue;
110 : }
111 0 : else if (old_rel->reloid > new_rel->reloid)
112 : {
113 : /* new_rel is unmatched, see comment above */
114 0 : if (strcmp(new_rel->nspname, "pg_toast") != 0)
115 : {
116 0 : report_unmatched_relation(new_rel, new_db, true);
117 0 : all_matched = false;
118 0 : }
119 0 : new_relnum++;
120 0 : 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 0 : if (strcmp(old_rel->nspname, new_rel->nspname) != 0 ||
129 0 : strcmp(old_rel->relname, new_rel->relname) != 0)
130 : {
131 0 : 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 0 : old_rel->reloid, old_db->db_name,
134 0 : old_rel->nspname, old_rel->relname,
135 0 : new_rel->nspname, new_rel->relname);
136 0 : all_matched = false;
137 0 : old_relnum++;
138 0 : new_relnum++;
139 0 : continue;
140 : }
141 :
142 : /* OK, create a mapping entry */
143 0 : create_rel_filename_map(old_pgdata, new_pgdata, old_db, new_db,
144 0 : old_rel, new_rel, maps + num_maps);
145 0 : num_maps++;
146 0 : old_relnum++;
147 0 : new_relnum++;
148 0 : }
149 :
150 0 : if (!all_matched)
151 0 : pg_fatal("Failed to match up old and new tables in database \"%s\"",
152 0 : old_db->db_name);
153 :
154 0 : *nmaps = num_maps;
155 0 : return maps;
156 0 : }
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 0 : 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 0 : 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 0 : map->old_tablespace = old_data;
178 0 : map->old_tablespace_suffix = "/base";
179 0 : }
180 : else
181 : {
182 : /* relation belongs to a tablespace, so use the tablespace location */
183 0 : map->old_tablespace = old_rel->tablespace;
184 0 : map->old_tablespace_suffix = old_cluster.tablespace_suffix;
185 : }
186 :
187 : /* Do the same for new tablespaces */
188 0 : if (strlen(new_rel->tablespace) == 0)
189 : {
190 0 : map->new_tablespace = new_data;
191 0 : map->new_tablespace_suffix = "/base";
192 0 : }
193 : else
194 : {
195 0 : map->new_tablespace = new_rel->tablespace;
196 0 : map->new_tablespace_suffix = new_cluster.tablespace_suffix;
197 : }
198 :
199 : /* DB oid and relfilenumbers are preserved between old and new cluster */
200 0 : map->db_oid = old_db->db_oid;
201 0 : map->relfilenumber = old_rel->relfilenumber;
202 :
203 : /* used only for logging and error reporting, old/new are identical */
204 0 : map->nspname = old_rel->nspname;
205 0 : map->relname = old_rel->relname;
206 0 : }
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 0 : report_unmatched_relation(const RelInfo *rel, const DbInfo *db, bool is_new_db)
215 : {
216 0 : Oid reloid = rel->reloid; /* we might change rel below */
217 0 : char reldesc[1000];
218 0 : int i;
219 :
220 0 : snprintf(reldesc, sizeof(reldesc), "\"%s.%s\"",
221 0 : rel->nspname, rel->relname);
222 0 : if (rel->indtable)
223 : {
224 0 : for (i = 0; i < db->rel_arr.nrels; i++)
225 : {
226 0 : const RelInfo *hrel = &db->rel_arr.rels[i];
227 :
228 0 : if (hrel->reloid == rel->indtable)
229 : {
230 0 : snprintf(reldesc + strlen(reldesc),
231 0 : sizeof(reldesc) - strlen(reldesc),
232 0 : _(" which is an index on \"%s.%s\""),
233 0 : hrel->nspname, hrel->relname);
234 : /* Shift attention to index's table for toast check */
235 0 : rel = hrel;
236 0 : break;
237 : }
238 0 : }
239 0 : if (i >= db->rel_arr.nrels)
240 0 : snprintf(reldesc + strlen(reldesc),
241 0 : sizeof(reldesc) - strlen(reldesc),
242 0 : _(" which is an index on OID %u"), rel->indtable);
243 0 : }
244 0 : if (rel->toastheap)
245 : {
246 0 : for (i = 0; i < db->rel_arr.nrels; i++)
247 : {
248 0 : const RelInfo *brel = &db->rel_arr.rels[i];
249 :
250 0 : if (brel->reloid == rel->toastheap)
251 : {
252 0 : snprintf(reldesc + strlen(reldesc),
253 0 : sizeof(reldesc) - strlen(reldesc),
254 0 : _(" which is the TOAST table for \"%s.%s\""),
255 0 : brel->nspname, brel->relname);
256 0 : break;
257 : }
258 0 : }
259 0 : if (i >= db->rel_arr.nrels)
260 0 : snprintf(reldesc + strlen(reldesc),
261 0 : sizeof(reldesc) - strlen(reldesc),
262 0 : _(" which is the TOAST table for OID %u"), rel->toastheap);
263 0 : }
264 :
265 0 : if (is_new_db)
266 0 : pg_log(PG_WARNING, "No match found in old cluster for new relation with OID %u in database \"%s\": %s",
267 0 : reloid, db->db_name, reldesc);
268 : else
269 0 : pg_log(PG_WARNING, "No match found in new cluster for old relation with OID %u in database \"%s\": %s",
270 0 : reloid, db->db_name, reldesc);
271 0 : }
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
280 0 : get_db_rel_and_slot_infos(ClusterInfo *cluster)
281 : {
282 0 : UpgradeTask *task = upgrade_task_create();
283 0 : char *rel_infos_query = NULL;
284 0 : char *logical_slot_infos_query = NULL;
285 :
286 0 : if (cluster->dbarr.dbs != NULL)
287 0 : free_db_and_rel_infos(&cluster->dbarr);
288 :
289 0 : get_template0_info(cluster);
290 0 : get_db_infos(cluster);
291 :
292 0 : rel_infos_query = get_rel_infos_query();
293 0 : upgrade_task_add_step(task,
294 0 : rel_infos_query,
295 : process_rel_infos,
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 0 : if (cluster == &old_cluster &&
308 0 : GET_MAJOR_VERSION(cluster->major_version) > 1600)
309 : {
310 0 : logical_slot_infos_query = get_old_cluster_logical_slot_infos_query();
311 0 : upgrade_task_add_step(task,
312 0 : logical_slot_infos_query,
313 : process_old_cluster_logical_slot_infos,
314 : true, NULL);
315 0 : }
316 :
317 0 : upgrade_task_run(task, cluster);
318 0 : upgrade_task_free(task);
319 :
320 0 : pg_free(rel_infos_query);
321 0 : if (logical_slot_infos_query)
322 0 : pg_free(logical_slot_infos_query);
323 :
324 0 : if (cluster == &old_cluster)
325 0 : pg_log(PG_VERBOSE, "\nsource databases:");
326 : else
327 0 : pg_log(PG_VERBOSE, "\ntarget databases:");
328 :
329 0 : if (log_opts.verbose)
330 0 : print_db_infos(&cluster->dbarr);
331 0 : }
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
339 0 : get_template0_info(ClusterInfo *cluster)
340 : {
341 0 : PGconn *conn = connectToServer(cluster, "template1");
342 0 : DbLocaleInfo *locale;
343 0 : PGresult *dbres;
344 0 : int i_datencoding;
345 0 : int i_datlocprovider;
346 0 : int i_datcollate;
347 0 : int i_datctype;
348 0 : int i_datlocale;
349 :
350 0 : if (GET_MAJOR_VERSION(cluster->major_version) >= 1700)
351 0 : dbres = executeQueryOrDie(conn,
352 : "SELECT encoding, datlocprovider, "
353 : " datcollate, datctype, datlocale "
354 : "FROM pg_catalog.pg_database "
355 : "WHERE datname='template0'");
356 0 : else if (GET_MAJOR_VERSION(cluster->major_version) >= 1500)
357 0 : 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 0 : 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 0 : if (PQntuples(dbres) != 1)
371 0 : pg_fatal("template0 not found");
372 :
373 0 : locale = pg_malloc(sizeof(DbLocaleInfo));
374 :
375 0 : i_datencoding = PQfnumber(dbres, "encoding");
376 0 : i_datlocprovider = PQfnumber(dbres, "datlocprovider");
377 0 : i_datcollate = PQfnumber(dbres, "datcollate");
378 0 : i_datctype = PQfnumber(dbres, "datctype");
379 0 : i_datlocale = PQfnumber(dbres, "datlocale");
380 :
381 0 : locale->db_encoding = atoi(PQgetvalue(dbres, 0, i_datencoding));
382 0 : locale->db_collprovider = PQgetvalue(dbres, 0, i_datlocprovider)[0];
383 0 : locale->db_collate = pg_strdup(PQgetvalue(dbres, 0, i_datcollate));
384 0 : locale->db_ctype = pg_strdup(PQgetvalue(dbres, 0, i_datctype));
385 0 : if (PQgetisnull(dbres, 0, i_datlocale))
386 0 : locale->db_locale = NULL;
387 : else
388 0 : locale->db_locale = pg_strdup(PQgetvalue(dbres, 0, i_datlocale));
389 :
390 0 : cluster->template0 = locale;
391 :
392 0 : PQclear(dbres);
393 0 : PQfinish(conn);
394 0 : }
395 :
396 :
397 : /*
398 : * get_db_infos()
399 : *
400 : * Scans pg_database system catalog and populates all user
401 : * databases.
402 : */
403 : static void
404 0 : get_db_infos(ClusterInfo *cluster)
405 : {
406 0 : PGconn *conn = connectToServer(cluster, "template1");
407 0 : PGresult *res;
408 0 : int ntups;
409 0 : int tupnum;
410 0 : DbInfo *dbinfos;
411 0 : int i_datname,
412 : i_oid,
413 : i_spclocation;
414 0 : char query[QUERY_ALLOC];
415 :
416 0 : snprintf(query, sizeof(query),
417 : "SELECT d.oid, d.datname, d.encoding, d.datcollate, d.datctype, ");
418 0 : if (GET_MAJOR_VERSION(cluster->major_version) >= 1700)
419 0 : snprintf(query + strlen(query), sizeof(query) - strlen(query),
420 : "datlocprovider, datlocale, ");
421 0 : else if (GET_MAJOR_VERSION(cluster->major_version) >= 1500)
422 0 : snprintf(query + strlen(query), sizeof(query) - strlen(query),
423 : "datlocprovider, daticulocale AS datlocale, ");
424 : else
425 0 : snprintf(query + strlen(query), sizeof(query) - strlen(query),
426 : "'c' AS datlocprovider, NULL AS datlocale, ");
427 0 : 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 0 : res = executeQueryOrDie(conn, "%s", query);
436 :
437 0 : i_oid = PQfnumber(res, "oid");
438 0 : i_datname = PQfnumber(res, "datname");
439 0 : i_spclocation = PQfnumber(res, "spclocation");
440 :
441 0 : ntups = PQntuples(res);
442 0 : dbinfos = (DbInfo *) pg_malloc0(sizeof(DbInfo) * ntups);
443 :
444 0 : for (tupnum = 0; tupnum < ntups; tupnum++)
445 : {
446 0 : char *spcloc = PQgetvalue(res, tupnum, i_spclocation);
447 0 : bool inplace = spcloc[0] && !is_absolute_path(spcloc);
448 :
449 0 : dbinfos[tupnum].db_oid = atooid(PQgetvalue(res, tupnum, i_oid));
450 0 : dbinfos[tupnum].db_name = pg_strdup(PQgetvalue(res, tupnum, i_datname));
451 :
452 : /*
453 : * The tablespace location might be "", meaning the cluster default
454 : * location, i.e. pg_default or pg_global. For in-place tablespaces,
455 : * pg_tablespace_location() returns a path relative to the data
456 : * directory.
457 : */
458 0 : if (inplace)
459 0 : snprintf(dbinfos[tupnum].db_tablespace,
460 : sizeof(dbinfos[tupnum].db_tablespace),
461 0 : "%s/%s", cluster->pgdata, spcloc);
462 : else
463 0 : snprintf(dbinfos[tupnum].db_tablespace,
464 : sizeof(dbinfos[tupnum].db_tablespace),
465 0 : "%s", spcloc);
466 0 : }
467 0 : PQclear(res);
468 :
469 0 : PQfinish(conn);
470 :
471 0 : cluster->dbarr.dbs = dbinfos;
472 0 : cluster->dbarr.ndbs = ntups;
473 0 : }
474 :
475 :
476 : /*
477 : * get_rel_infos_query()
478 : *
479 : * Returns the query for retrieving the relation information for all the user
480 : * tables and indexes in the database, for use by get_db_rel_and_slot_infos()'s
481 : * UpgradeTask.
482 : *
483 : * Note: the result is assumed to be sorted by OID. This allows later
484 : * processing to match up old and new databases efficiently.
485 : */
486 : static char *
487 0 : get_rel_infos_query(void)
488 : {
489 0 : PQExpBufferData query;
490 :
491 0 : initPQExpBuffer(&query);
492 :
493 : /*
494 : * Create a CTE that collects OIDs of regular user tables and matviews,
495 : * but excluding toast tables and indexes. We assume that relations with
496 : * OIDs >= FirstNormalObjectId belong to the user. (That's probably
497 : * redundant with the namespace-name exclusions, but let's be safe.)
498 : *
499 : * pg_largeobject contains user data that does not appear in pg_dump
500 : * output, so we have to copy that system table. It's easiest to do that
501 : * by treating it as a user table. We can do the same for
502 : * pg_largeobject_metadata for upgrades from v16 and newer. pg_upgrade
503 : * can't copy/link the files from older versions because aclitem (needed
504 : * by pg_largeobject_metadata.lomacl) changed its storage format in v16.
505 : */
506 0 : appendPQExpBuffer(&query,
507 : "WITH regular_heap (reloid, indtable, toastheap) AS ( "
508 : " SELECT c.oid, 0::oid, 0::oid "
509 : " FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n "
510 : " ON c.relnamespace = n.oid "
511 : " WHERE relkind IN (" CppAsString2(RELKIND_RELATION) ", "
512 : CppAsString2(RELKIND_MATVIEW) "%s) AND "
513 : /* exclude possible orphaned temp tables */
514 : " ((n.nspname !~ '^pg_temp_' AND "
515 : " n.nspname !~ '^pg_toast_temp_' AND "
516 : " n.nspname NOT IN ('pg_catalog', 'information_schema', "
517 : " 'binary_upgrade', 'pg_toast') AND "
518 : " c.oid >= %u::pg_catalog.oid) OR "
519 : " (n.nspname = 'pg_catalog' AND "
520 : " relname IN ('pg_largeobject'%s) ))), ",
521 0 : (user_opts.transfer_mode == TRANSFER_MODE_SWAP) ?
522 : ", " CppAsString2(RELKIND_SEQUENCE) : "",
523 : FirstNormalObjectId,
524 0 : (GET_MAJOR_VERSION(old_cluster.major_version) >= 1600) ?
525 : ", 'pg_largeobject_metadata'" : "");
526 :
527 : /*
528 : * Add a CTE that collects OIDs of toast tables belonging to the tables
529 : * selected by the regular_heap CTE. (We have to do this separately
530 : * because the namespace-name rules above don't work for toast tables.)
531 : */
532 0 : appendPQExpBufferStr(&query,
533 : " toast_heap (reloid, indtable, toastheap) AS ( "
534 : " SELECT c.reltoastrelid, 0::oid, c.oid "
535 : " FROM regular_heap JOIN pg_catalog.pg_class c "
536 : " ON regular_heap.reloid = c.oid "
537 : " WHERE c.reltoastrelid != 0), ");
538 :
539 : /*
540 : * Add a CTE that collects OIDs of all valid indexes on the previously
541 : * selected tables. We can ignore invalid indexes since pg_dump does.
542 : * Testing indisready is necessary in 9.2, and harmless in earlier/later
543 : * versions.
544 : */
545 0 : appendPQExpBufferStr(&query,
546 : " all_index (reloid, indtable, toastheap) AS ( "
547 : " SELECT indexrelid, indrelid, 0::oid "
548 : " FROM pg_catalog.pg_index "
549 : " WHERE indisvalid AND indisready "
550 : " AND indrelid IN "
551 : " (SELECT reloid FROM regular_heap "
552 : " UNION ALL "
553 : " SELECT reloid FROM toast_heap)) ");
554 :
555 : /*
556 : * And now we can write the query that retrieves the data we want for each
557 : * heap and index relation. Make sure result is sorted by OID.
558 : */
559 0 : appendPQExpBufferStr(&query,
560 : "SELECT all_rels.*, n.nspname, c.relname, "
561 : " c.relfilenode, c.reltablespace, "
562 : " pg_catalog.pg_tablespace_location(t.oid) AS spclocation "
563 : "FROM (SELECT * FROM regular_heap "
564 : " UNION ALL "
565 : " SELECT * FROM toast_heap "
566 : " UNION ALL "
567 : " SELECT * FROM all_index) all_rels "
568 : " JOIN pg_catalog.pg_class c "
569 : " ON all_rels.reloid = c.oid "
570 : " JOIN pg_catalog.pg_namespace n "
571 : " ON c.relnamespace = n.oid "
572 : " LEFT OUTER JOIN pg_catalog.pg_tablespace t "
573 : " ON c.reltablespace = t.oid "
574 : "ORDER BY 1");
575 :
576 0 : return query.data;
577 0 : }
578 :
579 : /*
580 : * Callback function for processing results of the query returned by
581 : * get_rel_infos_query(), which is used for get_db_rel_and_slot_infos()'s
582 : * UpgradeTask. This function stores the relation information for later use.
583 : */
584 : static void
585 0 : process_rel_infos(DbInfo *dbinfo, PGresult *res, void *arg)
586 : {
587 0 : int ntups = PQntuples(res);
588 0 : RelInfo *relinfos = (RelInfo *) pg_malloc(sizeof(RelInfo) * ntups);
589 0 : int i_reloid = PQfnumber(res, "reloid");
590 0 : int i_indtable = PQfnumber(res, "indtable");
591 0 : int i_toastheap = PQfnumber(res, "toastheap");
592 0 : int i_nspname = PQfnumber(res, "nspname");
593 0 : int i_relname = PQfnumber(res, "relname");
594 0 : int i_relfilenumber = PQfnumber(res, "relfilenode");
595 0 : int i_reltablespace = PQfnumber(res, "reltablespace");
596 0 : int i_spclocation = PQfnumber(res, "spclocation");
597 0 : int num_rels = 0;
598 0 : char *nspname = NULL;
599 0 : char *relname = NULL;
600 0 : char *tablespace = NULL;
601 0 : char *last_namespace = NULL;
602 0 : char *last_tablespace = NULL;
603 :
604 0 : for (int relnum = 0; relnum < ntups; relnum++)
605 : {
606 0 : RelInfo *curr = &relinfos[num_rels++];
607 :
608 0 : curr->reloid = atooid(PQgetvalue(res, relnum, i_reloid));
609 0 : curr->indtable = atooid(PQgetvalue(res, relnum, i_indtable));
610 0 : curr->toastheap = atooid(PQgetvalue(res, relnum, i_toastheap));
611 :
612 0 : nspname = PQgetvalue(res, relnum, i_nspname);
613 0 : curr->nsp_alloc = false;
614 :
615 : /*
616 : * Many of the namespace and tablespace strings are identical, so we
617 : * try to reuse the allocated string pointers where possible to reduce
618 : * memory consumption.
619 : */
620 : /* Can we reuse the previous string allocation? */
621 0 : if (last_namespace && strcmp(nspname, last_namespace) == 0)
622 0 : curr->nspname = last_namespace;
623 : else
624 : {
625 0 : last_namespace = curr->nspname = pg_strdup(nspname);
626 0 : curr->nsp_alloc = true;
627 : }
628 :
629 0 : relname = PQgetvalue(res, relnum, i_relname);
630 0 : curr->relname = pg_strdup(relname);
631 :
632 0 : curr->relfilenumber = atooid(PQgetvalue(res, relnum, i_relfilenumber));
633 0 : curr->tblsp_alloc = false;
634 :
635 : /* Is the tablespace oid non-default? */
636 0 : if (atooid(PQgetvalue(res, relnum, i_reltablespace)) != 0)
637 : {
638 0 : char *spcloc = PQgetvalue(res, relnum, i_spclocation);
639 0 : bool inplace = spcloc[0] && !is_absolute_path(spcloc);
640 :
641 : /*
642 : * The tablespace location might be "", meaning the cluster
643 : * default location, i.e. pg_default or pg_global. For in-place
644 : * tablespaces, pg_tablespace_location() returns a path relative
645 : * to the data directory.
646 : */
647 0 : if (inplace)
648 0 : tablespace = psprintf("%s/%s",
649 0 : os_info.running_cluster->pgdata,
650 0 : spcloc);
651 : else
652 0 : tablespace = spcloc;
653 :
654 : /* Can we reuse the previous string allocation? */
655 0 : if (last_tablespace && strcmp(tablespace, last_tablespace) == 0)
656 0 : curr->tablespace = last_tablespace;
657 : else
658 : {
659 0 : last_tablespace = curr->tablespace = pg_strdup(tablespace);
660 0 : curr->tblsp_alloc = true;
661 : }
662 :
663 : /* Free palloc'd string for in-place tablespaces. */
664 0 : if (inplace)
665 0 : pfree(tablespace);
666 0 : }
667 : else
668 : /* A zero reltablespace oid indicates the database tablespace. */
669 0 : curr->tablespace = dbinfo->db_tablespace;
670 0 : }
671 :
672 0 : dbinfo->rel_arr.rels = relinfos;
673 0 : dbinfo->rel_arr.nrels = num_rels;
674 0 : }
675 :
676 : /*
677 : * get_old_cluster_logical_slot_infos_query()
678 : *
679 : * Returns the query for retrieving the logical slot information for all the
680 : * logical replication slots in the database, for use by
681 : * get_db_rel_and_slot_infos()'s UpgradeTask. The status of each logical slot
682 : * is checked in check_old_cluster_for_valid_slots().
683 : */
684 : static char *
685 0 : get_old_cluster_logical_slot_infos_query(void)
686 : {
687 : /*
688 : * Fetch the logical replication slot information. The check whether the
689 : * slot is considered caught up is done by an upgrade function. This
690 : * regards the slot as caught up if we don't find any decodable changes.
691 : * See binary_upgrade_logical_slot_has_caught_up().
692 : *
693 : * Note that we can't ensure whether the slot is caught up during
694 : * live_check as the new WAL records could be generated.
695 : *
696 : * We intentionally skip checking the WALs for invalidated slots as the
697 : * corresponding WALs could have been removed for such slots.
698 : *
699 : * The temporary slots are explicitly ignored while checking because such
700 : * slots cannot exist after the upgrade. During the upgrade, clusters are
701 : * started and stopped several times causing any temporary slots to be
702 : * removed.
703 : */
704 0 : return psprintf("SELECT slot_name, plugin, two_phase, failover, "
705 : "%s as caught_up, invalidation_reason IS NOT NULL as invalid "
706 : "FROM pg_catalog.pg_replication_slots "
707 : "WHERE slot_type = 'logical' AND "
708 : "database = current_database() AND "
709 : "temporary IS FALSE;",
710 0 : user_opts.live_check ? "FALSE" :
711 : "(CASE WHEN invalidation_reason IS NOT NULL THEN FALSE "
712 : "ELSE (SELECT pg_catalog.binary_upgrade_logical_slot_has_caught_up(slot_name)) "
713 : "END)");
714 : }
715 :
716 : /*
717 : * Callback function for processing results of the query returned by
718 : * get_old_cluster_logical_slot_infos_query(), which is used for
719 : * get_db_rel_and_slot_infos()'s UpgradeTask. This function stores the logical
720 : * slot information for later use.
721 : */
722 : static void
723 0 : process_old_cluster_logical_slot_infos(DbInfo *dbinfo, PGresult *res, void *arg)
724 : {
725 0 : LogicalSlotInfo *slotinfos = NULL;
726 0 : int num_slots = PQntuples(res);
727 :
728 0 : if (num_slots)
729 : {
730 0 : int i_slotname;
731 0 : int i_plugin;
732 0 : int i_twophase;
733 0 : int i_failover;
734 0 : int i_caught_up;
735 0 : int i_invalid;
736 :
737 0 : slotinfos = (LogicalSlotInfo *) pg_malloc(sizeof(LogicalSlotInfo) * num_slots);
738 :
739 0 : i_slotname = PQfnumber(res, "slot_name");
740 0 : i_plugin = PQfnumber(res, "plugin");
741 0 : i_twophase = PQfnumber(res, "two_phase");
742 0 : i_failover = PQfnumber(res, "failover");
743 0 : i_caught_up = PQfnumber(res, "caught_up");
744 0 : i_invalid = PQfnumber(res, "invalid");
745 :
746 0 : for (int slotnum = 0; slotnum < num_slots; slotnum++)
747 : {
748 0 : LogicalSlotInfo *curr = &slotinfos[slotnum];
749 :
750 0 : curr->slotname = pg_strdup(PQgetvalue(res, slotnum, i_slotname));
751 0 : curr->plugin = pg_strdup(PQgetvalue(res, slotnum, i_plugin));
752 0 : curr->two_phase = (strcmp(PQgetvalue(res, slotnum, i_twophase), "t") == 0);
753 0 : curr->failover = (strcmp(PQgetvalue(res, slotnum, i_failover), "t") == 0);
754 0 : curr->caught_up = (strcmp(PQgetvalue(res, slotnum, i_caught_up), "t") == 0);
755 0 : curr->invalid = (strcmp(PQgetvalue(res, slotnum, i_invalid), "t") == 0);
756 0 : }
757 0 : }
758 :
759 0 : dbinfo->slot_arr.slots = slotinfos;
760 0 : dbinfo->slot_arr.nslots = num_slots;
761 0 : }
762 :
763 :
764 : /*
765 : * count_old_cluster_logical_slots()
766 : *
767 : * Returns the number of logical replication slots for all databases.
768 : *
769 : * Note: this function always returns 0 if the old_cluster is PG16 and prior
770 : * because we gather slot information only for cluster versions greater than or
771 : * equal to PG17. See get_old_cluster_logical_slot_infos().
772 : */
773 : int
774 0 : count_old_cluster_logical_slots(void)
775 : {
776 0 : int slot_count = 0;
777 :
778 0 : for (int dbnum = 0; dbnum < old_cluster.dbarr.ndbs; dbnum++)
779 0 : slot_count += old_cluster.dbarr.dbs[dbnum].slot_arr.nslots;
780 :
781 0 : return slot_count;
782 0 : }
783 :
784 : /*
785 : * get_subscription_info()
786 : *
787 : * Gets the information of subscriptions in the cluster.
788 : */
789 : void
790 0 : get_subscription_info(ClusterInfo *cluster)
791 : {
792 0 : PGconn *conn;
793 0 : PGresult *res;
794 0 : int i_nsub;
795 0 : int i_retain_dead_tuples;
796 :
797 0 : conn = connectToServer(cluster, "template1");
798 0 : if (GET_MAJOR_VERSION(cluster->major_version) >= 1900)
799 0 : res = executeQueryOrDie(conn, "SELECT count(*) AS nsub,"
800 : "COUNT(CASE WHEN subretaindeadtuples THEN 1 END) > 0 AS retain_dead_tuples "
801 : "FROM pg_catalog.pg_subscription");
802 : else
803 0 : res = executeQueryOrDie(conn, "SELECT count(*) AS nsub,"
804 : "'f' AS retain_dead_tuples "
805 : "FROM pg_catalog.pg_subscription");
806 :
807 0 : i_nsub = PQfnumber(res, "nsub");
808 0 : i_retain_dead_tuples = PQfnumber(res, "retain_dead_tuples");
809 :
810 0 : cluster->nsubs = atoi(PQgetvalue(res, 0, i_nsub));
811 0 : cluster->sub_retain_dead_tuples = (strcmp(PQgetvalue(res, 0, i_retain_dead_tuples), "t") == 0);
812 :
813 0 : PQclear(res);
814 0 : PQfinish(conn);
815 0 : }
816 :
817 : static void
818 0 : free_db_and_rel_infos(DbInfoArr *db_arr)
819 : {
820 0 : int dbnum;
821 :
822 0 : for (dbnum = 0; dbnum < db_arr->ndbs; dbnum++)
823 : {
824 0 : free_rel_infos(&db_arr->dbs[dbnum].rel_arr);
825 0 : pg_free(db_arr->dbs[dbnum].db_name);
826 0 : }
827 0 : pg_free(db_arr->dbs);
828 0 : db_arr->dbs = NULL;
829 0 : db_arr->ndbs = 0;
830 0 : }
831 :
832 :
833 : static void
834 0 : free_rel_infos(RelInfoArr *rel_arr)
835 : {
836 0 : int relnum;
837 :
838 0 : for (relnum = 0; relnum < rel_arr->nrels; relnum++)
839 : {
840 0 : if (rel_arr->rels[relnum].nsp_alloc)
841 0 : pg_free(rel_arr->rels[relnum].nspname);
842 0 : pg_free(rel_arr->rels[relnum].relname);
843 0 : if (rel_arr->rels[relnum].tblsp_alloc)
844 0 : pg_free(rel_arr->rels[relnum].tablespace);
845 0 : }
846 0 : pg_free(rel_arr->rels);
847 0 : rel_arr->nrels = 0;
848 0 : }
849 :
850 :
851 : static void
852 0 : print_db_infos(DbInfoArr *db_arr)
853 : {
854 0 : int dbnum;
855 :
856 0 : for (dbnum = 0; dbnum < db_arr->ndbs; dbnum++)
857 : {
858 0 : DbInfo *pDbInfo = &db_arr->dbs[dbnum];
859 :
860 0 : pg_log(PG_VERBOSE, "Database: \"%s\"", pDbInfo->db_name);
861 0 : print_rel_infos(&pDbInfo->rel_arr);
862 0 : print_slot_infos(&pDbInfo->slot_arr);
863 0 : }
864 0 : }
865 :
866 :
867 : static void
868 0 : print_rel_infos(RelInfoArr *rel_arr)
869 : {
870 0 : int relnum;
871 :
872 0 : for (relnum = 0; relnum < rel_arr->nrels; relnum++)
873 0 : pg_log(PG_VERBOSE, "relname: \"%s.%s\", reloid: %u, reltblspace: \"%s\"",
874 0 : rel_arr->rels[relnum].nspname,
875 0 : rel_arr->rels[relnum].relname,
876 0 : rel_arr->rels[relnum].reloid,
877 0 : rel_arr->rels[relnum].tablespace);
878 0 : }
879 :
880 : static void
881 0 : print_slot_infos(LogicalSlotInfoArr *slot_arr)
882 : {
883 : /* Quick return if there are no logical slots. */
884 0 : if (slot_arr->nslots == 0)
885 0 : return;
886 :
887 0 : pg_log(PG_VERBOSE, "Logical replication slots in the database:");
888 :
889 0 : for (int slotnum = 0; slotnum < slot_arr->nslots; slotnum++)
890 : {
891 0 : LogicalSlotInfo *slot_info = &slot_arr->slots[slotnum];
892 :
893 0 : pg_log(PG_VERBOSE, "slot name: \"%s\", output plugin: \"%s\", two_phase: %s",
894 0 : slot_info->slotname,
895 0 : slot_info->plugin,
896 0 : slot_info->two_phase ? "true" : "false");
897 0 : }
898 0 : }
|
