8000 tableam: relation creation, VACUUM FULL/CLUSTER, SET TABLESPACE. · postgrespro/postgres@d25f519 · GitHub
[go: up one dir, main page]
Skip to content

Commit d25f519

Browse files
anarazelanarazel
committed
tableam: relation creation, VACUUM FULL/CLUSTER, SET TABLESPACE.
This moves the responsibility for: - creating the storage necessary for a relation, including creating a new relfilenode for a relation with existing storage - non-transactional truncation of a relation - VACUUM FULL / CLUSTER's rewrite of a table below tableam. This is fairly straight forward, with a bit of complexity smattered in to move the computation of xid / multixid horizons below the AM, as they don't make sense for every table AM. Author: Andres Freund Discussion: https://postgr.es/m/20180703070645.wchpu5muyto5n647@alap3.anarazel.de
1 parent 7e69323 commit d25f519

File tree

13 files changed

+856
-579
lines changed

13 files changed

+856
-579
lines changed

‎src/backend/access/heap/heapam_handler.c

Lines changed: 451 additions & 0 deletions
Large diffs are not rendered by default.

‎src/backend/bootstrap/bootparse.y

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -209,6 +209,9 @@ Boot_CreateStmt:
209209

210210
if ($4)
211211
{
212+
TransactionId relfrozenxid;
213+
MultiXactId relminmxid;
214+
212215
if (boot_reldesc)
213216
{
214217
elog(DEBUG4, "create bootstrap: warning, open relation exists, closing first");
@@ -226,7 +229,9 @@ Boot_CreateStmt:
226229
RELPERSISTENCE_PERMANENT,
227230
shared_relation,
228231
mapped_relation,
229-
true);
232+
true,
233+
&relfrozenxid,
234+
&relminmxid);
230235
elog(DEBUG4, "bootstrap relation created");
231236
}
232237
else

‎src/backend/catalog/heap.c

Lines changed: 49 additions & 71 deletions
Original file line numberDiff line numberDiff line change
@@ -35,6 +35,7 @@
3535
#include "access/relation.h"
3636
#include "access/sysattr.h"
3737
#include "access/table.h"
38+
#include "access/tableam.h"
3839
#include "access/transam.h"
3940
#include "access/xact.h"
4041
#include "access/xlog.h"
@@ -98,6 +99,8 @@ static void AddNewRelationTuple(Relation pg_class_desc,
9899
Oid reloftype,
99100
Oid relowner,
100101
char relkind,
102+
TransactionId relfrozenxid,
103+
TransactionId relminmxid,
101104
Datum relacl,
102105
Datum reloptions);
103106
static ObjectAddress AddNewRelationType(const char *typeName,
@@ -300,7 +303,9 @@ heap_create(const char *relname,
300303
char relpersistence,
301304
bool shared_relation,
302305
bool mapped_relation,
303-
bool allow_system_table_mods)
306+
bool allow_system_table_mods,
307+
TransactionId *relfrozenxid,
308+
MultiXactId *relminmxid)
304309
{
305310
bool create_storage;
306311
Relation rel;
@@ -327,6 +332,9 @@ heap_create(const char *relname,
327332
get_namespace_name(relnamespace), relname),
328333
errdetail("System catalog modifications are currently disallowed.")));
329334

335+
*relfrozenxid = InvalidTransactionId;
336+
*relminmxid = InvalidMultiXactId;
337+
330338
/* Handle reltablespace for specific relkinds. */
331339
switch (relkind)
332340
{
@@ -400,13 +408,36 @@ heap_create(const char *relname,
400408
/*
401409
* Have the storage manager create the relation's disk file, if needed.
402410
*
403-
* We only create the main fork here, other forks will be created on
404-
* demand.
411+
* For relations the callback creates both the main and the init fork, for
412+
* indexes only the main fork is created. The other forks will be created
413+
* on demand.
405414
*/
406415
if (create_storage)
407416
{
408417
RelationOpenSmgr(rel);
409-
RelationCreateStorage(rel->rd_node, relpersistence);
418+
419+
switch (rel->rd_rel->relkind)
420+
{
421+
case RELKIND_VIEW:
422+
case RELKIND_COMPOSITE_TYPE:
423+
case RELKIND_FOREIGN_TABLE:
424+
case RELKIND_PARTITIONED_TABLE:
425+
case RELKIND_PARTITIONED_INDEX:
426+
Assert(false);
427+
break;
428+
429+
case RELKIND_INDEX:
430+
case RELKIND_SEQUENCE:
431+
RelationCreateStorage(rel->rd_node, relpersistence);
432+
break;
433+
434+
case RELKIND_RELATION:
435+
case RELKIND_TOASTVALUE:
436+
case RELKIND_MATVIEW:
437+
table_relation_set_new_filenode(rel, relpersistence,
438+
relfrozenxid, relminmxid);
439+
break;
440+
}
410441
}
411442

412443
return rel;
@@ -892,6 +923,8 @@ AddNewRelationTuple(Relation pg_class_desc,
892923
Oid reloftype,
893924
Oid relowner,
894925
char relkind,
926+
TransactionId relfrozenxid,
927+
TransactionId relminmxid,
895928
Datum relacl,
896929
Datum reloptions)
897930
{
@@ -928,40 +961,8 @@ AddNewRelationTuple(Relation pg_class_desc,
928961
break;
929962
}
930963

931< 10000 /td>-
/* Initialize relfrozenxid and relminmxid */
932-
if (relkind == RELKIND_RELATION ||
933-
relkind == RELKIND_MATVIEW ||
934-
relkind == RELKIND_TOASTVALUE)
935-
{
936-
/*
937-
* Initialize to the minimum XID that could put tuples in the table.
938-
* We know that no xacts older than RecentXmin are still running, so
939-
* that will do.
940-
*/
941-
new_rel_reltup->relfrozenxid = RecentXmin;
942-
943-
/*
944-
* Similarly, initialize the minimum Multixact to the first value that
945-
* could possibly be stored in tuples in the table. Running
946-
* transactions could reuse values from their local cache, so we are
947-
* careful to consider all currently running multis.
948-
*
949-
* XXX this could be refined further, but is it worth the hassle?
950-
*/
951-
new_rel_reltup->relminmxid = GetOldestMultiXactId();
952-
}
953-
else
954-
{
955-
/*
956-
* Other relation types will not contain XIDs, so set relfrozenxid to
957-
* InvalidTransactionId. (Note: a sequence does contain a tuple, but
958-
* we force its xmin to be FrozenTransactionId always; see
959-
* commands/sequence.c.)
960-
*/
961-
new_rel_reltup->relfrozenxid = InvalidTransactionId;
962-
new_rel_reltup->relminmxid = InvalidMultiXactId;
963-
}
964-
964+
new_rel_reltup->relfrozenxid = relfrozenxid;
965+
new_rel_reltup->relminmxid = relminmxid;
965966
new_rel_reltup->relowner = relowner;
966967
new_rel_reltup->reltype = new_type_oid;
967968
new_rel_reltup->reloftype = reloftype;
@@ -1089,6 +1090,8 @@ heap_create_with_catalog(const char *relname,
10891090
Oid new_type_oid;
10901091
ObjectAddress new_type_addr;
10911092
Oid new_array_oid = InvalidOid;
1093+
TransactionId relfrozenxid;
1094+
MultiXactId relminmxid;
10921095

10931096
pg_class_desc = table_open(RelationRelationId, RowExclusiveLock);
10941097

@@ -1220,7 +1223,9 @@ heap_create_with_catalog(const char *relname,
12201223
relpersistence,
12211224
shared_relation,
12221225
mapped_relation,
1223-
allow_system_table_mods);
1226+
allow_system_table_mods,
1227+
&relfrozenxid,
1228+
&relminmxid);
12241229

12251230
Assert(relid == RelationGetRelid(new_rel_desc));
12261231

@@ -1319,6 +1324,8 @@ heap_create_with_catalog(const char *relname,
13191324
reloftypeid,
13201325
ownerid,
13211326
relkind,
1327+
relfrozenxid,
1328+
relminmxid,
13221329
PointerGetDatum(relacl),
13231330
reloptions);
13241331

@@ -1407,14 +1414,6 @@ heap_create_with_catalog(const char *relname,
14071414
if (oncommit != ONCOMMIT_NOOP)
14081415
register_on_commit_action(relid, oncommit);
14091416

1410-
/*
1411-
* Unlogged objects need an init fork, except for partitioned tables which
1412-
* have no storage at all.
1413-
*/
1414-
if (relpersistence == RELPERSISTENCE_UNLOGGED &&
1415-
relkind != RELKIND_PARTITIONED_TABLE)
1416-
heap_create_init_fork(new_rel_desc);
1417-
14181417
/*
14191418
* ok, the relation has been cataloged, so close our relations and return
14201419
* the OID of the newly created relation.
@@ -1425,27 +1424,6 @@ heap_create_with_catalog(const char *relname,
14251424
return relid;
14261425
}
14271426

1428-
/*
1429-
* Set up an init fork for an unlogged table so that it can be correctly
1430-
* reinitialized on restart. An immediate sync is required even if the
1431-
* page has been logged, because the F438 write did not go through
1432-
* shared_buffers and therefore a concurrent checkpoint may have moved
1433-
* the redo pointer past our xlog record. Recovery may as well remove it
1434-
* while replaying, for example, XLOG_DBASE_CREATE or XLOG_TBLSPC_CREATE
1435-
* record. Therefore, logging is necessary even if wal_level=minimal.
1436-
*/
1437-
void
1438-
heap_create_init_fork(Relation rel)
1439-
{
1440-
Assert(rel->rd_rel->relkind == RELKIND_RELATION ||
1441-
rel->rd_rel->relkind == RELKIND_MATVIEW ||
1442-
rel->rd_rel->relkind == RELKIND_TOASTVALUE);
1443-
RelationOpenSmgr(rel);
1444-
smgrcreate(rel->rd_smgr, INIT_FORKNUM, false);
1445-
log_smgrcreate(&rel->rd_smgr->smgr_rnode.node, INIT_FORKNUM);
1446-
smgrimmedsync(rel->rd_smgr, INIT_FORKNUM);
1447-
}
1448-
14491427
/*
14501428
* RelationRemoveInheritance
14511429
*
@@ -3168,8 +3146,8 @@ heap_truncate_one_rel(Relation rel)
31683146
if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
31693147
return;
31703148

3171-
/* Truncate the actual file (and discard buffers) */
3172-
RelationTruncate(rel, 0);
3149+
/* Truncate the underlying relation */
3150+
table_relation_nontransactional_truncate(rel);
31733151

31743152
/* If the relation has indexes, truncate the indexes too */
31753153
RelationTruncateIndexes(rel);
@@ -3180,7 +3158,7 @@ heap_truncate_one_rel(Relation rel)
31803158
{
31813159
Relation toastrel = table_open(toastrelid, AccessExclusiveLock);
31823160

3183-
RelationTruncate(toastrel, 0);
3161+
table_relation_nontransactional_truncate(toastrel);
31843162
RelationTruncateIndexes(toastrel);
31853163
/* keep the lock... */
31863164
table_close(toastrel, NoLock);

‎src/backend/catalog/index.c

Lines changed: 8 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -739,6 +739,8 @@ index_create(Relation heapRelation,
739739
bool concurrent = (flags & INDEX_CREATE_CONCURRENT) != 0;
740740
bool partitioned = (flags & INDEX_CREATE_PARTITIONED) != 0;
741741
char relkind;
742+
TransactionId relfrozenxid;
743+
MultiXactId relminmxid;
742744

743745
/* constraint flags can only be set when a constraint is requested */
744746
Assert((constr_flags == 0) ||
@@ -899,8 +901,12 @@ index_create(Relation heapRelation,
899901
relpersistence,
900902
shared_relation,
901903
mapped_relation,
902-
allow_system_table_mods);
904+
allow_system_table_mods,
905+
&relfrozenxid,
906+
&relminmxid);
903907

908+
Assert(relfrozenxid == InvalidTransactionId);
909+
Assert(relminmxid == InvalidMultiXactId);
904910
Assert(indexRelationId == RelationGetRelid(indexRelation));
905911

906912
/*
@@ -2850,8 +2856,7 @@ reindex_index(Oid indexId, bool skip_constraint_checks, char persistence,
28502856
}
28512857

28522858
/* We'll build a new physical relation for the index */
2853-
RelationSetNewRelfilenode(iRel, persistence, InvalidTransactionId,
2854-
InvalidMultiXactId);
2859+
RelationSetNewRelfilenode(iRel, persistence);
28552860

28562861
/* Initialize the index and rebuild */
28572862
/* Note: we do not need to re-establish pkey setting */

‎src/backend/catalog/storage.c

Lines changed: 88 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,8 @@
1919

2020
#include "postgres.h"
2121

22+
#include "miscadmin.h"
23+
2224
#include "access/visibilitymap.h"
2325
#include "access/xact.h"
2426
#include "access/xlog.h"
@@ -290,6 +292,92 @@ RelationTruncate(Relation rel, BlockNumber nblocks)
290292
smgrtruncate(rel->rd_smgr, MAIN_FORKNUM, nblocks);
291293
}
292294

295+
/*
296+
* Copy a fork's data, block by block.
297+
*/
298+
void
299+
RelationCopyStorage(SMgrRelation src, SMgrRelation dst,
300+
ForkNumber forkNum, char relpersistence)
301+
{
302+
PGAlignedBlock buf;
303+
Page page;
304+
bool use_wal;
305+
bool copying_initfork;
306+
BlockNumber nblocks;
307+
BlockNumber blkno;
308+
309+
page = (Page) buf.data;
310+
311+
/*
312+
* The init fork for an unlogged relation in many respects has to be
313+
* treated the same as normal relation, changes need to be WAL logged and
314+
* it needs to be synced to disk.
315+
*/
316+
copying_initfork = relpersistence == RELPERSISTENCE_UNLOGGED &&
317+
forkNum == INIT_FORKNUM;
318+
319+
/*
320+
* We need to log the copied data in WAL iff WAL archiving/streaming is
321+
* enabled AND it's a permanent relation.
322+
*/
323+
use_wal = XLogIsNeeded() &&
324+
(relpersistence == RELPERSISTENCE_PERMANENT || copying_initfork);
325+
326+
nblocks = smgrnblocks(src, forkNum);
327+
328+
for (blkno = 0; blkno < nblocks; blkno++)
329+
{
330+
/* If we got a cancel signal during the copy of the data, quit */
331+
CHECK_FOR_INTERRUPTS();
332+
333+
smgrread(src, forkNum, blkno, buf.data);
334+
335+
if (!PageIsVerified(page, blkno))
336+
ereport(ERROR,
337+
(errcode(ERRCODE_DATA_CORRUPTED),
338+
errmsg("invalid page in block %u of relation %s",
339+
blkno,
340+
relpathbackend(src->smgr_rnode.node,
341+
src->smgr_rnode.backend,
342+
forkNum))));
343+
344+
/*
345+
* WAL-log the copied page. Unfortunately we don't know what kind of a
346+
* page this is, so we have to log the full page including any unused
347+
* space.
348+
*/
349+
if (use_wal)
350+
log_newpage(&dst->smgr_rnode.node, forkNum, blkno, page, false);
351+
352+
PageSetChecksumInplace(page, blkno);
353+
354+
/*
355+
* Now write the page. We say isTemp = true even if it's not a temp
356+
* rel, because there's no need for smgr to schedule an fsync for this
357+
* write; we'll do it ourselves below.
358+
*/
359+
smgrextend(dst, forkNum, blkno, buf.data, true);
360+
}
361+
362+
/*
363+
* If the rel is WAL-logged, must fsync before commit. We use heap_sync
364+
* to ensure that the toast table gets fsync'd too. (For a temp or
365+
* unlogged rel we don't care since the data will be gone after a crash
366+
* anyway.)
367+
*
368+
* It's obvious that we must do this when not WAL-logging the copy. It's
369+
* less obvious that we have to do it even if we did WAL-log the copied
370+
* pages. The reason is that since we're copying outside shared buffers, a
371+
* CHECKPOINT occurring during the copy has no way to flush the previously
372+
* written data to disk (indeed it won't know the new rel even exists). A
373+
* crash later on would replay WAL from the checkpoint, therefore it
374+
* wouldn't replay our earlier WAL entries. If we do not fsync those pages
375+
* here, they might still not be on disk when the crash occurs.
376+
*/
377+
if (relpersistence == RELPERSISTENCE_PERMANENT || copying_initfork)
378+
smgrimmedsync(dst, forkNum);
379+
}
380+
293381
/*
294382
* smgrDoPendingDeletes() -- Take care of relation deletes at end of xact.
295383
*

0 commit comments

Comments
 (0)
0