ginxlog.c Source File (original) (raw)

24static void

26{

32 {

38 }

41}

43static void

45{

48 char *ptr;

68}

70static void

72{

79 {

85 }

87 if (data->isDelete)

88 {

92 }

94 itup = &data->tuple;

97 {

101

102 BufferGetTag(buffer, &locator, &forknum, &blknum);

103 elog(ERROR, "failed to add item to index page in %u/%u/%u",

105 }

106}

107

108

109

110

111

112

113

114

115

116static void

118{

119 int actionno;

120 int segno;

123 char *walbuf;

124 int totalsize;

128

129

130

131

133 {

136 int npacked;

137

138

139

140

141

142

143

144 if (nuncompressed > 0)

145 {

147

149 BLCKSZ, &npacked);

151

152 Assert(npacked == nuncompressed);

153

155 }

156 else

157 {

158 totalsize = 0;

159 }

160

164 }

165

167 writePtr = (Pointer) oldseg;

169 segno = 0;

170

172 for (actionno = 0; actionno < data->nactions; actionno++)

173 {

174 uint8 a_segno = *((uint8 *) (walbuf++));

175 uint8 a_action = *((uint8 *) (walbuf++));

177 int newsegsize = 0;

181 int nolditems;

183 int nnewitems;

184 int segsize;

185

186

189 {

193 }

194

196 {

198 walbuf += sizeof(uint16);

201 }

202

203

204 Assert(segno <= a_segno);

205 while (segno < a_segno)

206 {

207

208

209

210

212 if (tailCopy)

213 {

215 memcpy(writePtr, (Pointer) oldseg, segsize);

216 }

217 writePtr += segsize;

219 segno++;

220 }

221

222

223

224

225

226

228 {

229 int npacked;

230

232

234 olditems, nolditems,

235 &nnewitems);

237

239 BLCKSZ, &npacked);

240 Assert(npacked == nnewitems);

241

244 }

245

246 segptr = (Pointer) oldseg;

247 if (segptr != segmentend)

249 else

250 {

251

252

253

254

256 segsize = 0;

257 }

258

259

260

261

262

263 if (!tailCopy && segptr != segmentend)

264 {

265 int tailSize = segmentend - segptr;

266

268 memcpy(tailCopy, segptr, tailSize);

269 segptr = tailCopy;

271 segmentend = segptr + tailSize;

272 }

273

274 switch (a_action)

275 {

277 segptr += segsize;

278 segno++;

279 break;

280

282

284 memcpy(writePtr, newseg, newsegsize);

285 writePtr += newsegsize;

286 break;

287

289

291 memcpy(writePtr, newseg, newsegsize);

292 writePtr += newsegsize;

293 segptr += segsize;

294 segno++;

295 break;

296

297 default:

298 elog(ERROR, "unexpected GIN leaf action: %u", a_action);

299 }

301 }

302

303

304 segptr = (Pointer) oldseg;

305 if (segptr != segmentend && tailCopy)

306 {

307 int restSize = segmentend - segptr;

308

310 memcpy(writePtr, segptr, restSize);

311 writePtr += restSize;

312 }

313

316}

317

318static void

320{

322

323 if (isLeaf)

324 {

326

328

330 }

331 else

332 {

335

337

338

341

343 }

344}

345

346static void

348{

352#ifdef NOT_USED

354#endif

357

358

359

360

361

362 if (!isLeaf)

363 {

365

366#ifdef NOT_USED

368#endif

372

374 }

375

377 {

381

382

384 {

387 }

388 else

389 {

392 }

393

396 }

399}

400

401static void

403{

406 rbuffer,

407 rootbuf;

410

411

412

413

414

415 if (!isLeaf)

417

419 elog(ERROR, "GIN split record did not contain a full-page image of left page");

420

422 elog(ERROR, "GIN split record did not contain a full-page image of right page");

423

424 if (isRoot)

425 {

427 elog(ERROR, "GIN split record did not contain a full-page image of root page");

429 }

430

433}

434

435

436

437

438

439static void

441{

443

445 {

446 elog(ERROR, "replay of gin entry tree page vacuum did not restore the page");

447 }

449}

450

451static void

453{

456

458 {

462

464

467

471 }

474}

475

476static void

478{

485

486

487

488

489

491 {

497 }

498

500 {

507 }

508

510 {

517 }

518

525}

526

527static void

529{

533 Page metapage;

535

536

537

538

539

540

544

549

550 if (data->ntuples > 0)

551 {

552

553

554

556 {

559 int i;

560 Size tupsize;

561 char *payload;

563 Size totaltupsize;

564

567

570 else

572

573 for (i = 0; i < data->ntuples; i++)

574 {

576

579 elog(ERROR, "failed to add item to index page");

580

581 tuples = (IndexTuple) (((char *) tuples) + tupsize);

582

583 off++;

584 }

585 Assert(payload + totaltupsize == (char *) tuples);

586

587

588

589

591

594 }

597 }

599 {

600

601

602

604 {

606

608

611 }

614 }

615

617}

618

619static void

621{

628 int i,

629 tupsize;

630 char *payload;

632 Size totaltupsize;

633

634

637

641 {

642

645 }

646 else

647 {

649 }

650

652

654 for (i = 0; i < data->ntuples; i++)

655 {

657

658 l = PageAddItem(page, (Item) tuples, tupsize, off, false, false);

659

661 elog(ERROR, "failed to add item to index page");

662

663 tuples = (IndexTuple) (((char *) tuples) + tupsize);

664 off++;

665 }

666 Assert((char *) tuples == payload + totaltupsize);

667

670

672}

673

674static void

676{

680 Page metapage;

681 int i;

682

686

688

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708 for (i = 0; i < data->ndeleted; i++)

709 {

712

716

719

721 }

723}

724

725void

727{

730

731

732

733

734

735

736

738 switch (info)

739 {

742 break;

745 break;

748 break;

751 break;

754 break;

757 break;

760 break;

763 break;

766 break;

767 default:

768 elog(PANIC, "gin_redo: unknown op code %u", info);

769 }

772}

773

774void

776{

778 "GIN recovery temporary context",

780}

781

782void

784{

787}

788

789

790

791

792void

794{

798

801

803

804

805

806

807

808

813}

struct BlockIdData BlockIdData

#define InvalidBlockNumber

static BlockNumber BlockIdGetBlockNumber(const BlockIdData *blockId)

void mask_page_content(Page page)

void mask_page_lsn_and_checksum(Page page)

void mask_unused_space(Page page)

void mask_page_hint_bits(Page page)

BlockNumber BufferGetBlockNumber(Buffer buffer)

void BufferGetTag(Buffer buffer, RelFileLocator *rlocator, ForkNumber *forknum, BlockNumber *blknum)

void UnlockReleaseBuffer(Buffer buffer)

void MarkBufferDirty(Buffer buffer)

static Page BufferGetPage(Buffer buffer)

static bool BufferIsValid(Buffer bufnum)

void PageIndexTupleDelete(Page page, OffsetNumber offnum)

static bool PageIsEmpty(const PageData *page)

PageHeaderData * PageHeader

#define PageGetSpecialPointer(page)

static Item PageGetItem(const PageData *page, const ItemIdData *itemId)

#define SizeOfPageHeaderData

static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)

static void PageSetLSN(Page page, XLogRecPtr lsn)

#define PageAddItem(page, item, size, offsetNumber, overwrite, is_heap)

static OffsetNumber PageGetMaxOffsetNumber(const PageData *page)

#define GIN_METAPAGE_BLKNO

#define GinPageGetOpaque(page)

#define SizeOfGinPostingList(plist)

#define GinPageSetDeleteXid(page, xid)

#define GinDataLeafPageGetPostingListSize(page)

#define GinSetDownlink(itup, blkno)

#define GinDataPageSetDataSize(page, size)

#define GinPageSetCompressed(page)

#define GinNextPostingListSegment(cur)

#define GinPageIsData(page)

#define GinPageGetMeta(p)

#define GinDataPageGetPostingItem(page, i)

#define GinDataPageGetData(page)

#define PostingItemSetBlockNumber(pointer, blockNumber)

#define GinPageIsCompressed(page)

#define GinPageSetDeleted(page)

#define GinPageIsLeaf(page)

#define GinPageSetFullRow(page)

#define GinDataLeafPageGetPostingList(page)

void GinPageDeletePostingItem(Page page, OffsetNumber offset)

void GinDataPageAddPostingItem(Page page, PostingItem *data, OffsetNumber offset)

ItemPointer ginPostingListDecode(GinPostingList *plist, int *ndecoded_out)

GinPostingList * ginCompressPostingList(const ItemPointer ipd, int nipd, int maxsize, int *nwritten)

ItemPointer ginMergeItemPointers(ItemPointerData *a, uint32 na, ItemPointerData *b, uint32 nb, int *nmerged)

void GinInitBuffer(Buffer b, uint32 f)

void GinInitMetabuffer(Buffer b)

static void ginRedoInsertEntry(Buffer buffer, bool isLeaf, BlockNumber rightblkno, void *rdata)

static void ginRedoInsert(XLogReaderState *record)

static void ginRedoSplit(XLogReaderState *record)

void gin_redo(XLogReaderState *record)

void gin_mask(char *pagedata, BlockNumber blkno)

static void ginRedoClearIncompleteSplit(XLogReaderState *record, uint8 block_id)

void gin_xlog_startup(void)

static void ginRedoDeletePage(XLogReaderState *record)

static void ginRedoVacuumDataLeafPage(XLogReaderState *record)

static void ginRedoDeleteListPages(XLogReaderState *record)

static void ginRedoUpdateMetapage(XLogReaderState *record)

static void ginRedoInsertData(Buffer buffer, bool isLeaf, BlockNumber rightblkno, void *rdata)

void gin_xlog_cleanup(void)

static void ginRedoInsertListPage(XLogReaderState *record)

static MemoryContext opCtx

static void ginRedoCreatePTree(XLogReaderState *record)

static void ginRedoRecompress(Page page, ginxlogRecompressDataLeaf *data)

static void ginRedoVacuumPage(XLogReaderState *record)

#define GIN_INSERT_ISDATA

#define GIN_INSERT_ISLEAF

#define XLOG_GIN_UPDATE_META_PAGE

#define GIN_SEGMENT_ADDITEMS

#define GIN_SEGMENT_DELETE

#define XLOG_GIN_CREATE_PTREE

#define XLOG_GIN_VACUUM_PAGE

#define XLOG_GIN_DELETE_PAGE

#define XLOG_GIN_INSERT_LISTPAGE

#define XLOG_GIN_VACUUM_DATA_LEAF_PAGE

struct ginxlogCreatePostingTree ginxlogCreatePostingTree

#define GIN_SEGMENT_INSERT

#define XLOG_GIN_DELETE_LISTPAGE

#define GIN_SEGMENT_REPLACE

Assert(PointerIsAligned(start, uint64))

ItemPointerData * ItemPointer

struct ItemPointerData ItemPointerData

IndexTupleData * IndexTuple

static Size IndexTupleSize(const IndexTupleData *itup)

void MemoryContextReset(MemoryContext context)

MemoryContext CurrentMemoryContext

void MemoryContextDelete(MemoryContext context)

#define AllocSetContextCreate

#define ALLOCSET_DEFAULT_SIZES

#define InvalidOffsetNumber

#define OffsetNumberNext(offsetNumber)

#define FirstOffsetNumber

static MemoryContext MemoryContextSwitchTo(MemoryContext context)

ginxlogRecompressDataLeaf data

char * XLogRecGetBlockData(XLogReaderState *record, uint8 block_id, Size *len)

#define XLogRecGetInfo(decoder)

#define XLogRecGetData(decoder)

XLogRedoAction XLogReadBufferForRedo(XLogReaderState *record, uint8 block_id, Buffer *buf)

Buffer XLogInitBufferForRedo(XLogReaderState *record, uint8 block_id)