spgxlog.c Source File (original) (raw)

34static void

36{

42}

49static void

51{

53 {

58 elog(ERROR, "SPGiST tuple to be replaced is not a placeholder");

64 }

68 if (PageAddItem(page, tuple, size, offset, false, false) != offset)

69 elog(ERROR, "failed to add item of size %u to SPGiST index page",

70 size);

71}

73static void

75{

79 char *leafTuple;

86 leafTuple = ptr;

96 {

101 }

102 else

104

106 {

108

109

111 {

112

115

116

118 {

120

125 }

126 }

127 else

128 {

129

132 (Item) leafTuple, leafTupleHdr.size,

134 elog(ERROR, "failed to add item of size %u to SPGiST index page",

135 leafTupleHdr.size);

136 }

137

140 }

143

144

146 {

148 {

151

153

155

158

161

164 }

167 }

168}

169

170static void

172{

179 int nInsert;

184

186

188

190

196

197

198

199

200

201

202

203

204

205

207 {

212 }

213 else

215

217 {

218 int i;

219

221

222 for (i = 0; i < nInsert; i++)

223 {

224 char *leafTuple;

226

227

228

229

230

231 leafTuple = ptr;

232 memcpy(&leafTupleHdr, leafTuple,

234

236 leafTupleHdr.size, toInsert[i]);

237 ptr += leafTupleHdr.size;

238 }

239

242 }

245

246

248 {

250

254 blknoDst,

255 toInsert[nInsert - 1]);

256

259 }

262

263

265 {

267

269

272

274 blknoDst, toInsert[nInsert - 1]);

275

278 }

281}

282

283static void

285{

289 char *innerTuple;

295

297 innerTuple = ptr;

298

300

302

304 {

305

308 {

310

314 false, false) != xldata->offnum)

315 elog(ERROR, "failed to add item of size %u to SPGiST index page",

316 innerTupleHdr.size);

317

320 }

323 }

324 else

325 {

328

331

332

333

334

335

336

337

338

339

340

342 {

343

347 }

348 else

351 {

353

356

357

358

359

361 {

363

366

369 }

372 }

375

376

378 {

380

382

383 if (state.isBuild)

387 else

389 blknoNew,

391

395 false, false) != xldata->offnum)

396 elog(ERROR, "failed to add item of size %u to SPGiST index page",

398

399 if (state.isBuild)

401 else

403

404

405

406

408 {

410

413

416 }

419 }

422

423

424

425

426

428 {

430 {

432

434

437

440

443 }

446 }

447 }

448}

449

450static void

452{

456 char *prefixTuple;

458 char *postfixTuple;

463

465 prefixTuple = ptr;

466

468 ptr += prefixTupleHdr.size;

469 postfixTuple = ptr;

470

472

473

474

475

476

477

478

479

481 {

483 {

485

488 }

489 else

492 {

494

497

500 }

503 }

504

505

507 {

509

513 elog(ERROR, "failed to add item of size %u to SPGiST index page",

514 prefixTupleHdr.size);

515

518 postfixTupleHdr.size,

520

523 }

526}

527

528static void

530{

534 char *innerTuple;

539 uint8 *leafPageSelect;

543 Page srcPage;

544 Page destPage;

546 int i;

549

551

553

559 leafPageSelect = (uint8 *) ptr;

561

562 innerTuple = ptr;

563

565 ptr += innerTupleHdr.size;

566

567

568

570 {

571

573 srcPage = NULL;

574 }

575 else if (xldata->initSrc)

576 {

577

580

583

584 }

585 else

586 {

587

588

589

590

591

592

593 srcPage = NULL;

595 {

597

598

599

600

601

602

603 if ( state .isBuild)

605 toDelete, xldata->nDelete,

608 blknoInner,

610 else

612 toDelete, xldata->nDelete,

617

618

619 }

620 }

621

622

624 {

626 destPage = NULL;

627 }

629 {

630

633

636

637 }

638 else

639 {

640

641

642

643

646 else

647 destPage = NULL;

648 }

649

650

651 for (i = 0; i < xldata->nInsert; i++)

652 {

653 char *leafTuple;

655

656

657 leafTuple = ptr;

659 ptr += leafTupleHdr.size;

660

661 page = leafPageSelect[i] ? destPage : srcPage;

662 if (page == NULL)

663 continue;

664

666 toInsert[i]);

667 }

668

669

670 if (srcPage != NULL)

671 {

674 }

675 if (destPage != NULL)

676 {

679 }

680

681

683 {

687 }

688 else

690

692 {

694

697

698

700 {

702

707 }

708

711 }

714

715

716

717

718

723

724

726 {

728

730 {

732

734

739

742 }

745 }

746 else

748}

749

750static void

752{

765 int i;

766

768

781

783 {

785

787 toDead, xldata->nDead,

791

797

798

799 for (i = 0; i < xldata->nMove; i++)

800 {

804

805 tmp = *idSrc;

806 *idSrc = *idDest;

807 *idDest = tmp;

808 }

809

811 moveSrc, xldata->nMove,

815

816 for (i = 0; i < xldata->nChain; i++)

817 {

819

824 }

825

828 }

831}

832

833static void

835{

842

843 toDelete = xldata->offsets;

844

846 {

848

849

851

854 }

857}

858

859static void

861{

867

868 itemToPlaceholder = xldata->offsets;

869

870

871

872

873

875 {

877

881 locator);

882 }

883

885 {

888 int i;

889

890

892 {

894

900 }

901

905

906

908 {

911

913

916

920

921

923

925 }

926

929 }

932}

933

934void

936{

939

941 switch (info)

942 {

945 break;

948 break;

951 break;

954 break;

957 break;

960 break;

963 break;

966 break;

967 default:

968 elog(PANIC, "spg_redo: unknown op code %u", info);

969 }

970

973}

974

975void

977{

979 "SP-GiST temporary context",

981}

982

983void

985{

988}

989

990

991

992

993void

995{

998

1000

1002

1003

1004

1005

1006

1009}

#define InvalidBlockNumber

void mask_page_lsn_and_checksum(Page page)

void mask_unused_space(Page page)

void mask_page_hint_bits(Page page)

void UnlockReleaseBuffer(Buffer buffer)

void MarkBufferDirty(Buffer buffer)

static Page BufferGetPage(Buffer buffer)

static bool BufferIsValid(Buffer bufnum)

void PageIndexMultiDelete(Page page, OffsetNumber *itemnos, int nitems)

void PageIndexTupleDelete(Page page, OffsetNumber offnum)

PageHeaderData * PageHeader

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)

Assert(PointerIsAligned(start, uint64))

static void ItemPointerSetInvalid(ItemPointerData *pointer)

void MemoryContextReset(MemoryContext context)

void pfree(void *pointer)

void * palloc0(Size size)

MemoryContext CurrentMemoryContext

void MemoryContextDelete(MemoryContext context)

#define AllocSetContextCreate

#define ALLOCSET_DEFAULT_SIZES

#define InvalidOffsetNumber

static MemoryContext MemoryContextSwitchTo(MemoryContext context)

void spgPageIndexMultiDelete(SpGistState *state, Page page, OffsetNumber *itemnos, int nitems, int firststate, int reststate, BlockNumber blkno, OffsetNumber offnum)

void spgUpdateNodeLink(SpGistInnerTuple tup, int nodeN, BlockNumber blkno, OffsetNumber offset)

SpGistDeadTupleData * SpGistDeadTuple

SpGistInnerTupleData * SpGistInnerTuple

#define SGLT_GET_NEXTOFFSET(spgLeafTuple)

#define SPGIST_PLACEHOLDER

#define SGLT_SET_NEXTOFFSET(spgLeafTuple, offsetNumber)

struct SpGistLeafTupleData * SpGistLeafTuple

#define SpGistPageGetOpaque(page)

SpGistDeadTuple spgFormDeadTuple(SpGistState *state, int tupstate, BlockNumber blkno, OffsetNumber offnum)

void SpGistInitBuffer(Buffer b, uint16 f)

static void addOrReplaceTuple(Page page, Item tuple, int size, OffsetNumber offset)

void spg_redo(XLogReaderState *record)

static void spgRedoVacuumRoot(XLogReaderState *record)

static void spgRedoSplitTuple(XLogReaderState *record)

static void spgRedoVacuumRedirect(XLogReaderState *record)

void spg_xlog_cleanup(void)

void spg_mask(char *pagedata, BlockNumber blkno)

static void spgRedoMoveLeafs(XLogReaderState *record)

static void fillFakeState(SpGistState *state, spgxlogState stateSrc)

void spg_xlog_startup(void)

static void spgRedoAddNode(XLogReaderState *record)

static MemoryContext opCtx

static void spgRedoVacuumLeaf(XLogReaderState *record)

static void spgRedoPickSplit(XLogReaderState *record)

static void spgRedoAddLeaf(XLogReaderState *record)

struct spgxlogSplitTuple spgxlogSplitTuple

#define XLOG_SPGIST_SPLIT_TUPLE

#define SizeOfSpgxlogPickSplit

#define XLOG_SPGIST_VACUUM_ROOT

struct spgxlogAddLeaf spgxlogAddLeaf

#define SizeOfSpgxlogVacuumLeaf

#define SizeOfSpgxlogMoveLeafs

#define XLOG_SPGIST_VACUUM_LEAF

#define XLOG_SPGIST_ADD_NODE

#define XLOG_SPGIST_ADD_LEAF

struct spgxlogAddNode spgxlogAddNode

#define XLOG_SPGIST_MOVE_LEAFS

#define XLOG_SPGIST_PICKSPLIT

#define XLOG_SPGIST_VACUUM_REDIRECT

void ResolveRecoveryConflictWithSnapshot(TransactionId snapshotConflictHorizon, bool isCatalogRel, RelFileLocator locator)

OffsetNumber offnumHeadLeaf

OffsetNumber offnumParent

OffsetNumber offnumPostfix

OffsetNumber offnumPrefix

TransactionId redirectXid

OffsetNumber firstPlaceholder

TransactionId snapshotConflictHorizon

OffsetNumber offsets[FLEXIBLE_ARRAY_MEMBER]

void XLogRecGetBlockTag(XLogReaderState *record, uint8 block_id, RelFileLocator *rlocator, ForkNumber *forknum, BlockNumber *blknum)

#define XLogRecGetInfo(decoder)

#define XLogRecGetData(decoder)

#define XLogRecHasBlockRef(decoder, block_id)

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

Buffer XLogInitBufferForRedo(XLogReaderState *record, uint8 block_id)