Debian Codegraph @

src/backend/access/spgist/spginsert.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * spginsert.c
4 * Externally visible index creation/insertion routines
5 *
6 * All the actual insertion logic is in spgdoinsert.c.
7 *
8 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
9 * Portions Copyright (c) 1994, Regents of the University of California
10 *
11 * IDENTIFICATION
12 * src/backend/access/spgist/spginsert.c
13 *
14 *-------------------------------------------------------------------------
15 */
16
17 #include "postgres.h"
18
19 #include "access/genam.h"
20 #include "access/spgist_private.h"
21 #include "access/tableam.h"
22 #include "access/xloginsert.h"
23 #include "miscadmin.h"
24 #include "nodes/execnodes.h"
25 #include "storage/bufmgr.h"
26 #include "storage/bulk_write.h"
27 #include "utils/memutils.h"
28 #include "utils/rel.h"
29
30
31 typedef struct
32 {
33 SpGistState spgstate; /* SPGiST's working state */
34 int64 indtuples; /* total number of tuples indexed */
35 MemoryContext tmpCtx; /* per-tuple temporary context */
36 } SpGistBuildState;
37
38
39 /* Callback to process one heap tuple during table_index_build_scan */
40 static void
41 spgistBuildCallback(Relation index, ItemPointer tid, Datum *values,
42 bool *isnull, bool tupleIsAlive, void *state)
43 {
44 SpGistBuildState *buildstate = (SpGistBuildState *) state;
45 MemoryContext oldCtx;
46
47 /* Work in temp context, and reset it after each tuple */
48 oldCtx = MemoryContextSwitchTo(buildstate->tmpCtx);
49
50 /*
51 * Even though no concurrent insertions can be happening, we still might
52 * get a buffer-locking failure due to bgwriter or checkpointer taking a
53 * lock on some buffer. So we need to be willing to retry. We can flush
54 * any temp data when retrying.
55 */
56 while (!spgdoinsert(index, &buildstate->spgstate, tid,
57 values, isnull))
58 {
59 MemoryContextReset(buildstate->tmpCtx);
60 }
61
62 /* Update total tuple count */
63 buildstate->indtuples += 1;
64
65 MemoryContextSwitchTo(oldCtx);
66 MemoryContextReset(buildstate->tmpCtx);
67 }
68
69 /*
70 * Build an SP-GiST index.
71 */
72 IndexBuildResult *
73 spgbuild(Relation heap, Relation index, IndexInfo *indexInfo)
74 {
75 IndexBuildResult *result;
76 double reltuples;
77 SpGistBuildState buildstate;
78 Buffer metabuffer,
79 rootbuffer,
80 nullbuffer;
81
82 if (RelationGetNumberOfBlocks(index) != 0)
83 elog(ERROR, "index \"%s\" already contains data",
84 RelationGetRelationName(index));
85
86 /*
87 * Initialize the meta page and root pages
88 */
89 metabuffer = SpGistNewBuffer(index);
90 rootbuffer = SpGistNewBuffer(index);
91 nullbuffer = SpGistNewBuffer(index);
92
93 Assert(BufferGetBlockNumber(metabuffer) == SPGIST_METAPAGE_BLKNO);
94 Assert(BufferGetBlockNumber(rootbuffer) == SPGIST_ROOT_BLKNO);
95 Assert(BufferGetBlockNumber(nullbuffer) == SPGIST_NULL_BLKNO);
96
97 START_CRIT_SECTION();
98
99 SpGistInitMetapage(BufferGetPage(metabuffer));
100 MarkBufferDirty(metabuffer);
101 SpGistInitBuffer(rootbuffer, SPGIST_LEAF);
102 MarkBufferDirty(rootbuffer);
103 SpGistInitBuffer(nullbuffer, SPGIST_LEAF | SPGIST_NULLS);
104 MarkBufferDirty(nullbuffer);
105
106
107 END_CRIT_SECTION();
108
109 UnlockReleaseBuffer(metabuffer);
110 UnlockReleaseBuffer(rootbuffer);
111 UnlockReleaseBuffer(nullbuffer);
112
113 /*
114 * Now insert all the heap data into the index
115 */
116 initSpGistState(&buildstate.spgstate, index);
117 buildstate.spgstate.isBuild = true;
118 buildstate.indtuples = 0;
119
120 buildstate.tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
121 "SP-GiST build temporary context",
122 ALLOCSET_DEFAULT_SIZES);
123
124 reltuples = table_index_build_scan(heap, index, indexInfo, true, true,
125 spgistBuildCallback, &buildstate,
126 NULL);
127
128 MemoryContextDelete(buildstate.tmpCtx);
129
130 SpGistUpdateMetaPage(index);
131
132 /*
133 * We didn't write WAL records as we built the index, so if WAL-logging is
134 * required, write all pages to the WAL now.
135 */
136 if (RelationNeedsWAL(index))
137 {
138 log_newpage_range(index, MAIN_FORKNUM,
139 0, RelationGetNumberOfBlocks(index),
140 true);
141 }
142
143 result = (IndexBuildResult *) palloc0(sizeof(IndexBuildResult));
144 result->heap_tuples = reltuples;
145 result->index_tuples = buildstate.indtuples;
146
147 return result;
148 }
149
150 /*
151 * Build an empty SPGiST index in the initialization fork
152 */
153 void
154 spgbuildempty(Relation index)
155 {
156 BulkWriteState *bulkstate;
157 BulkWriteBuffer buf;
158
159 bulkstate = smgr_bulk_start_rel(index, INIT_FORKNUM);
160
161 /* Construct metapage. */
162 buf = smgr_bulk_get_buf(bulkstate);
163 SpGistInitMetapage((Page) buf);
164 smgr_bulk_write(bulkstate, SPGIST_METAPAGE_BLKNO, buf, true);
165
166 /* Likewise for the root page. */
167 buf = smgr_bulk_get_buf(bulkstate);
168 SpGistInitPage((Page) buf, SPGIST_LEAF);
169 smgr_bulk_write(bulkstate, SPGIST_ROOT_BLKNO, buf, true);
170
171 /* Likewise for the null-tuples root page. */
172 buf = smgr_bulk_get_buf(bulkstate);
173 SpGistInitPage((Page) buf, SPGIST_LEAF | SPGIST_NULLS);
174 smgr_bulk_write(bulkstate, SPGIST_NULL_BLKNO, buf, true);
175
176 smgr_bulk_finish(bulkstate);
177 }
178
179 /*
180 * Insert one new tuple into an SPGiST index.
181 */
182 bool
183 spginsert(Relation index, Datum *values, bool *isnull,
184 ItemPointer ht_ctid, Relation heapRel,
185 IndexUniqueCheck checkUnique,
186 bool indexUnchanged,
187 IndexInfo *indexInfo)
188 {
189 SpGistState spgstate;
190 MemoryContext oldCtx;
191 MemoryContext insertCtx;
192
193 insertCtx = AllocSetContextCreate(CurrentMemoryContext,
194 "SP-GiST insert temporary context",
195 ALLOCSET_DEFAULT_SIZES);
196 oldCtx = MemoryContextSwitchTo(insertCtx);
197
198 initSpGistState(&spgstate, index);
199
200 /*
201 * We might have to repeat spgdoinsert() multiple times, if conflicts
202 * occur with concurrent insertions. If so, reset the insertCtx each time
203 * to avoid cumulative memory consumption. That means we also have to
204 * redo initSpGistState(), but it's cheap enough not to matter.
205 */
206 while (!spgdoinsert(index, &spgstate, ht_ctid, values, isnull))
207 {
208 MemoryContextReset(insertCtx);
209 initSpGistState(&spgstate, index);
210 }
211
212 SpGistUpdateMetaPage(index);
213
214 MemoryContextSwitchTo(oldCtx);
215 MemoryContextDelete(insertCtx);
216
217 /* return false since we've not done any unique check */
218 return false;
219 }