Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit62401db

Browse files
committed
Support unlogged GiST index.
The reason this wasn't supported before was that GiST indexes need anincreasing sequence to detect concurrent page-splits. In a regular WAL-logged GiST index, the LSN of the page-split record is used for thatpurpose, and in a temporary index, we can get away with a backend-localcounter. Neither of those methods works for an unlogged relation.To provide such an increasing sequence of numbers, create a "fake LSN"counter that is saved and restored across shutdowns. On recovery, unloggedrelations are blown away, so the counter doesn't need to survive thateither.Jeevan Chalke, based on discussions with Robert Haas, Tom Lane and me.
1 parentb669f41 commit62401db

File tree

12 files changed

+121
-31
lines changed

12 files changed

+121
-31
lines changed

‎doc/src/sgml/ref/create_table.sgml‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -182,8 +182,7 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI
182182
automatically truncated after a crash or unclean shutdown. The contents
183183
of an unlogged table are also not replicated to standby servers.
184184
Any indexes created on an unlogged table are automatically unlogged as
185-
well; however, unlogged <link linkend="GiST">GiST indexes</link> are
186-
currently not supported and cannot be created on an unlogged table.
185+
well.
187186
</para>
188187
</listitem>
189188
</varlistentry>

‎src/backend/access/gist/gist.c‎

Lines changed: 19 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,7 @@
1616

1717
#include"access/genam.h"
1818
#include"access/gist_private.h"
19+
#include"access/heapam_xlog.h"
1920
#include"catalog/index.h"
2021
#include"catalog/pg_collation.h"
2122
#include"miscadmin.h"
@@ -71,9 +72,22 @@ createTempGistContext(void)
7172
Datum
7273
gistbuildempty(PG_FUNCTION_ARGS)
7374
{
74-
ereport(ERROR,
75-
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
76-
errmsg("unlogged GiST indexes are not supported")));
75+
Relationindex= (Relation)PG_GETARG_POINTER(0);
76+
Bufferbuffer;
77+
78+
/* Initialize the root page */
79+
buffer=ReadBufferExtended(index,INIT_FORKNUM,P_NEW,RBM_NORMAL,NULL);
80+
LockBuffer(buffer,BUFFER_LOCK_EXCLUSIVE);
81+
82+
/* Initialize and xlog buffer */
83+
START_CRIT_SECTION();
84+
GISTInitBuffer(buffer,F_LEAF);
85+
MarkBufferDirty(buffer);
86+
log_newpage_buffer(buffer);
87+
END_CRIT_SECTION();
88+
89+
/* Unlock and release the buffer */
90+
UnlockReleaseBuffer(buffer);
7791

7892
PG_RETURN_VOID();
7993
}
@@ -391,7 +405,7 @@ gistplacetopage(Relation rel, Size freespace, GISTSTATE *giststate,
391405
dist,oldrlink,oldnsn,leftchildbuf,
392406
markfollowright);
393407
else
394-
recptr=GetXLogRecPtrForTemp();
408+
recptr=gistGetFakeLSN(rel);
395409

396410
for (ptr=dist;ptr;ptr=ptr->next)
397411
{
@@ -448,7 +462,7 @@ gistplacetopage(Relation rel, Size freespace, GISTSTATE *giststate,
448462
}
449463
else
450464
{
451-
recptr=GetXLogRecPtrForTemp();
465+
recptr=gistGetFakeLSN(rel);
452466
PageSetLSN(page,recptr);
453467
}
454468

‎src/backend/access/gist/gistbuild.c‎

Lines changed: 1 addition & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -158,16 +158,6 @@ gistbuild(PG_FUNCTION_ARGS)
158158
elog(ERROR,"index \"%s\" already contains data",
159159
RelationGetRelationName(index));
160160

161-
/*
162-
* We can't yet handle unlogged GiST indexes, because we depend on LSNs.
163-
* This is duplicative of an error in gistbuildempty, but we want to check
164-
* here so as to throw error before doing all the index-build work.
165-
*/
166-
if (heap->rd_rel->relpersistence==RELPERSISTENCE_UNLOGGED)
167-
ereport(ERROR,
168-
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
169-
errmsg("unlogged GiST indexes are not supported")));
170-
171161
/* no locking is needed */
172162
buildstate.giststate=initGISTstate(index);
173163

@@ -204,7 +194,7 @@ gistbuild(PG_FUNCTION_ARGS)
204194
PageSetTLI(page,ThisTimeLineID);
205195
}
206196
else
207-
PageSetLSN(page,GetXLogRecPtrForTemp());
197+
PageSetLSN(page,gistGetFakeLSN(heap));
208198

209199
UnlockReleaseBuffer(buffer);
210200

‎src/backend/access/gist/gistutil.c‎

Lines changed: 22 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -798,16 +798,30 @@ gistoptions(PG_FUNCTION_ARGS)
798798
}
799799

800800
/*
801-
* Temporary GiST indexes are not WAL-logged, but we need LSNs to detect
802-
* concurrent page splits anyway. GetXLogRecPtrForTemp() provides a fake
803-
* sequence of LSNs for that purpose. Each call generates an LSN that is
804-
* greater than any previous value returned by this function in the same
805-
* session.
801+
* Temporary and unlogged GiST indexes are not WAL-logged, but we need LSNs
802+
* to detect concurrent page splits anyway. This function provides a fake
803+
* sequence of LSNs for that purpose.
806804
*/
807805
XLogRecPtr
808-
GetXLogRecPtrForTemp(void)
806+
gistGetFakeLSN(Relationrel)
809807
{
810808
staticXLogRecPtrcounter=1;
811-
counter++;
812-
returncounter;
809+
810+
if (rel->rd_rel->relpersistence==RELPERSISTENCE_TEMP)
811+
{
812+
/*
813+
* Temporary relations are only accessible in our session, so a
814+
* simple backend-local counter will do.
815+
*/
816+
returncounter++;
817+
}
818+
else
819+
{
820+
/*
821+
* Unlogged relations are accessible from other backends, and survive
822+
* (clean) restarts. GetFakeLSNForUnloggedRel() handles that for us.
823+
*/
824+
Assert(rel->rd_rel->relpersistence==RELPERSISTENCE_UNLOGGED);
825+
returnGetFakeLSNForUnloggedRel();
826+
}
813827
}

‎src/backend/access/gist/gistvacuum.c‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -238,7 +238,7 @@ gistbulkdelete(PG_FUNCTION_ARGS)
238238
PageSetTLI(page,ThisTimeLineID);
239239
}
240240
else
241-
PageSetLSN(page,GetXLogRecPtrForTemp());
241+
PageSetLSN(page,gistGetFakeLSN(rel));
242242

243243
END_CRIT_SECTION();
244244
}

‎src/backend/access/transam/xlog.c‎

Lines changed: 51 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -391,6 +391,10 @@ typedef struct XLogCtlData
391391
XLogRecPtrasyncXactLSN;/* LSN of newest async commit/abort */
392392
XLogSegNolastRemovedSegNo;/* latest removed/recycled XLOG segment */
393393

394+
/* Fake LSN counter, for unlogged relations. Protected by ulsn_lck */
395+
XLogRecPtrunloggedLSN;
396+
slock_tulsn_lck;
397+
394398
/* Protected by WALWriteLock: */
395399
XLogCtlWriteWrite;
396400

@@ -3696,6 +3700,31 @@ GetSystemIdentifier(void)
36963700
returnControlFile->system_identifier;
36973701
}
36983702

3703+
/*
3704+
* Returns a fake LSN for unlogged relations.
3705+
*
3706+
* Each call generates an LSN that is greater than any previous value
3707+
* returned. The current counter value is saved and restored across clean
3708+
* shutdowns, but like unlogged relations, does not survive a crash. This can
3709+
* be used in lieu of real LSN values returned by XLogInsert, if you need an
3710+
* LSN-like increasing sequence of numbers without writing any WAL.
3711+
*/
3712+
XLogRecPtr
3713+
GetFakeLSNForUnloggedRel(void)
3714+
{
3715+
XLogRecPtrnextUnloggedLSN;
3716+
3717+
/* use volatile pointer to prevent code rearrangement */
3718+
volatileXLogCtlData*xlogctl=XLogCtl;
3719+
3720+
/* increment the unloggedLSN counter, need SpinLock */
3721+
SpinLockAcquire(&xlogctl->ulsn_lck);
3722+
nextUnloggedLSN=xlogctl->unloggedLSN++;
3723+
SpinLockRelease(&xlogctl->ulsn_lck);
3724+
3725+
returnnextUnloggedLSN;
3726+
}
3727+
36993728
/*
37003729
* Auto-tune the number of XLOG buffers.
37013730
*
@@ -3844,6 +3873,7 @@ XLOGShmemInit(void)
38443873
XLogCtl->WalWriterSleeping= false;
38453874
XLogCtl->Insert.currpage= (XLogPageHeader) (XLogCtl->pages);
38463875
SpinLockInit(&XLogCtl->info_lck);
3876+
SpinLockInit(&XLogCtl->ulsn_lck);
38473877
InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
38483878

38493879
/*
@@ -3989,6 +4019,7 @@ BootStrapXLOG(void)
39894019
ControlFile->time=checkPoint.time;
39904020
ControlFile->checkPoint=checkPoint.redo;
39914021
ControlFile->checkPointCopy=checkPoint;
4022+
ControlFile->unloggedLSN=1;
39924023

39934024
/* Set important parameter values for use when replaying WAL */
39944025
ControlFile->MaxConnections=MaxConnections;
@@ -5032,6 +5063,16 @@ StartupXLOG(void)
50325063
XLogCtl->ckptXidEpoch=checkPoint.nextXidEpoch;
50335064
XLogCtl->ckptXid=checkPoint.nextXid;
50345065

5066+
/*
5067+
* Initialize unlogged LSN. On a clean shutdown, it's restored from the
5068+
* control file. On recovery, all unlogged relations are blown away, so
5069+
* the unlogged LSN counter can be reset too.
5070+
*/
5071+
if (ControlFile->state==DB_SHUTDOWNED)
5072+
XLogCtl->unloggedLSN=ControlFile->unloggedLSN;
5073+
else
5074+
XLogCtl->unloggedLSN=1;
5075+
50355076
/*
50365077
* We must replay WAL entries using the same TimeLineID they were created
50375078
* under, so temporarily adopt the TLI indicated by the checkpoint (see
@@ -6916,6 +6957,16 @@ CreateCheckPoint(int flags)
69166957
/* crash recovery should always recover to the end of WAL */
69176958
ControlFile->minRecoveryPoint=InvalidXLogRecPtr;
69186959
ControlFile->minRecoveryPointTLI=0;
6960+
6961+
/*
6962+
* Persist unloggedLSN value. It's reset on crash recovery, so this goes
6963+
* unused on non-shutdown checkpoints, but seems useful to store it always
6964+
* for debugging purposes.
6965+
*/
6966+
SpinLockAcquire(&XLogCtl->ulsn_lck);
6967+
ControlFile->unloggedLSN=XLogCtl->unloggedLSN;
6968+
SpinLockRelease(&XLogCtl->ulsn_lck);
6969+
69196970
UpdateControlFile();
69206971
LWLockRelease(ControlFileLock);
69216972

‎src/backend/storage/buffer/bufmgr.c‎

Lines changed: 17 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1922,9 +1922,24 @@ FlushBuffer(volatile BufferDesc *buf, SMgrRelation reln)
19221922
* Force XLOG flush up to buffer's LSN. This implements the basic WAL
19231923
* rule that log updates must hit disk before any of the data-file changes
19241924
* they describe do.
1925+
*
1926+
* However, this rule does not apply to unlogged relations, which will be
1927+
* lost after a crash anyway. Most unlogged relation pages do not bear
1928+
* LSNs since we never emit WAL records for them, and therefore flushing
1929+
* up through the buffer LSN would be useless, but harmless. However, GiST
1930+
* indexes use LSNs internally to track page-splits, and therefore unlogged
1931+
* GiST pages bear "fake" LSNs generated by GetFakeLSNForUnloggedRel. It
1932+
* is unlikely but possible that the fake LSN counter could advance past
1933+
* the WAL insertion point; and if it did happen, attempting to flush WAL
1934+
* through that location would fail, with disastrous system-wide
1935+
* consequences. To make sure that can't happen, skip the flush if the
1936+
* buffer isn't permanent.
19251937
*/
1926-
recptr=BufferGetLSN(buf);
1927-
XLogFlush(recptr);
1938+
if (buf->flags&BM_PERMANENT)
1939+
{
1940+
recptr=BufferGetLSN(buf);
1941+
XLogFlush(recptr);
1942+
}
19281943

19291944
/*
19301945
* Now it's safe to write buffer to disk. Note that no one else should

‎src/bin/pg_controldata/pg_controldata.c‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -240,6 +240,9 @@ main(int argc, char *argv[])
240240
ControlFile.checkPointCopy.oldestMultiDB);
241241
printf(_("Time of latest checkpoint: %s\n"),
242242
ckpttime_str);
243+
printf(_("Fake LSN counter for unlogged rels: %X/%X\n"),
244+
(uint32) (ControlFile.unloggedLSN >>32),
245+
(uint32)ControlFile.unloggedLSN);
243246
printf(_("Min recovery ending location: %X/%X\n"),
244247
(uint32) (ControlFile.minRecoveryPoint >>32),
245248
(uint32)ControlFile.minRecoveryPoint);

‎src/bin/pg_resetxlog/pg_resetxlog.c‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -510,6 +510,7 @@ GuessControlValues(void)
510510
ControlFile.state=DB_SHUTDOWNED;
511511
ControlFile.time= (pg_time_t)time(NULL);
512512
ControlFile.checkPoint=ControlFile.checkPointCopy.redo;
513+
ControlFile.unloggedLSN=1;
513514

514515
/* minRecoveryPoint, backupStartPoint and backupEndPoint can be left zero */
515516

‎src/include/access/gist_private.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -512,7 +512,7 @@ extern void gistMakeUnionKey(GISTSTATE *giststate, int attno,
512512
GISTENTRY*entry2,boolisnull2,
513513
Datum*dst,bool*dstisnull);
514514

515-
externXLogRecPtrGetXLogRecPtrForTemp(void);
515+
externXLogRecPtrgistGetFakeLSN(Relationrel);
516516

517517
/* gistvacuum.c */
518518
externDatumgistbulkdelete(PG_FUNCTION_ARGS);

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp