gistget.c File Reference (original) (raw)

Go to the source code of this file.

Functions
static void	gistkillitems (IndexScanDesc scan)

static bool	gistindex_keytest (IndexScanDesc scan, IndexTuple tuple, Page page, OffsetNumber offset, bool recheck_p, bool recheck_distances_p)

static void	gistScanPage (IndexScanDesc scan, GISTSearchItem pageItem, IndexOrderByDistance myDistances, TIDBitmap tbm, int64 ntids)

static GISTSearchItem *	getNextGISTSearchItem (GISTScanOpaque so)

static bool	getNextNearest (IndexScanDesc scan)

bool	gistgettuple (IndexScanDesc scan, ScanDirection dir)

int64	gistgetbitmap (IndexScanDesc scan, TIDBitmap *tbm)

bool	gistcanreturn (Relation index, int attno)

◆ getNextGISTSearchItem()

◆ getNextNearest()

Definition at line 560 of file gistget.c.

561{

563 bool res = false;

564

566 {

567

570 }

571

572 do

573 {

575

576 if (!item)

577 break;

578

580 {

581

584

588

589

592 res = true;

593 }

594 else

595 {

596

598

600 }

601

603 } while (!res);

604

605 return res;

606}

GISTScanOpaqueData * GISTScanOpaque

#define GISTSearchItemIsHeap(item)

static GISTSearchItem * getNextGISTSearchItem(GISTScanOpaque so)

static void gistScanPage(IndexScanDesc scan, GISTSearchItem *pageItem, IndexOrderByDistance *myDistances, TIDBitmap *tbm, int64 *ntids)

void index_store_float8_orderby_distances(IndexScanDesc scan, Oid *orderByTypes, IndexOrderByDistance *distances, bool recheckOrderBy)

if(TABLE==NULL||TABLE_index==NULL)

void pfree(void *pointer)

#define CHECK_FOR_INTERRUPTS()

IndexOrderByDistance distances[FLEXIBLE_ARRAY_MEMBER]

union GISTSearchItem::@45 data

ItemPointerData xs_heaptid

References CHECK_FOR_INTERRUPTS, GISTSearchItem::data, GISTSearchItem::distances, getNextGISTSearchItem(), gistScanPage(), GISTSearchItemIsHeap, GISTSearchItem::heap, GISTSearchHeapItem::heapPtr, if(), index_store_float8_orderby_distances(), IndexScanDescData::opaque, GISTScanOpaqueData::orderByTypes, pfree(), GISTSearchHeapItem::recheck, GISTSearchHeapItem::recheckDistances, GISTSearchHeapItem::recontup, IndexScanDescData::xs_heaptid, IndexScanDescData::xs_hitup, IndexScanDescData::xs_recheck, and IndexScanDescData::xs_want_itup.

Referenced by gistgettuple().

◆ gistcanreturn()

bool gistcanreturn	(	Relation	index,
int	attno
)

◆ gistgetbitmap()

Definition at line 745 of file gistget.c.

746{

750

752 return 0;

753

757

758

763

765 memset(&fakeItem.data.parentlsn, 0, sizeof(GistNSN));

766 gistScanPage(scan, &fakeItem, NULL, tbm, &ntids);

767

768

769

770

771

772 for (;;)

773 {

775

776 if (!item)

777 break;

778

780

782

784 }

785

786 return ntids;

787}

void MemoryContextReset(MemoryContext context)

#define pgstat_count_index_scan(rel)

MemoryContext pageDataCxt

struct IndexScanInstrumentation * instrument

References CHECK_FOR_INTERRUPTS, GISTScanOpaqueData::curPageData, GISTSearchItem::distances, getNextGISTSearchItem(), GIST_ROOT_BLKNO, gistScanPage(), if(), IndexScanDescData::indexRelation, IndexScanDescData::instrument, MemoryContextReset(), GISTScanOpaqueData::nPageData, IndexScanInstrumentation::nsearches, IndexScanDescData::opaque, GISTScanOpaqueData::pageDataCxt, pfree(), pgstat_count_index_scan, GISTScanOpaqueData::qual_ok, and IndexScanDescData::xs_hitup.

Referenced by gisthandler().

◆ gistgettuple()

Definition at line 612 of file gistget.c.

613{

615

617 elog(ERROR, "GiST only supports forward scan direction");

618

620 return false;

621

623 {

624

626

630

636

639 gistScanPage(scan, &fakeItem, NULL, NULL, NULL);

640 }

641

643 {

644

646 }

647 else

648 {

649

650 for (;;)

651 {

653 {

655 {

656

658 {

661

665

667 }

671 }

672

675

676

679

681

682 return true;

683 }

684

685

686

687

688

692 {

693

695 {

698

702

704 }

708 }

709

710 do

711 {

713

716

718

719 if (!item)

720 return false;

721

723

724

726

727

728

729

730

731

732

734

737 }

738 }

739}

#define InvalidBlockNumber

static bool getNextNearest(IndexScanDesc scan)

static void gistkillitems(IndexScanDesc scan)

#define MaxIndexTuplesPerPage

static MemoryContext MemoryContextSwitchTo(MemoryContext context)

OffsetNumber * killedItems

GISTSearchHeapItem pageData[BLCKSZ/sizeof(IndexTupleData)]

Referenced by gisthandler().

◆ gistindex_keytest()

Definition at line 125 of file gistget.c.

131{

138

139 *recheck_p = false;

140 *recheck_distances_p = false;

141

142

143

144

145

146

148 {

149 int i;

150

152 elog(ERROR, "invalid GiST tuple found on leaf page");

154 {

157 }

158 return true;

159 }

160

161

162 while (keySize > 0)

163 {

165 bool isNull;

166

168 key->sk_attno,

169 giststate->leafTupdesc,

170 &isNull);

171

173 {

174

175

176

177

178

179

181 {

183 return false;

184 }

185 else

186 {

188 if (isNull)

189 return false;

190 }

191 }

192 else if (isNull)

193 {

194 return false;

195 }

196 else

197 {

199 bool recheck;

201

203 datum, r, page, offset,

204 false, isNull);

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219 recheck = true;

220

222 key->sk_collation,

224 key->sk_argument,

228

230 return false;

231 *recheck_p |= recheck;

232 }

233

235 keySize--;

236 }

237

238

242 while (keySize > 0)

243 {

245 bool isNull;

246

248 key->sk_attno,

249 giststate->leafTupdesc,

250 &isNull);

251

253 {

254

255 distance_p->value = 0.0;

256 distance_p->isnull = true;

257 }

258 else

259 {

261 bool recheck;

263

265 datum, r, page, offset,

266 false, isNull);

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284 recheck = false;

286 key->sk_collation,

288 key->sk_argument,

292 *recheck_distances_p |= recheck;

294 distance_p->isnull = false;

295 }

296

298 distance_p++;

299 keySize--;

300 }

301

302 return true;

303}

static float8 get_float8_infinity(void)

Datum FunctionCall5Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5)

#define GistPageIsLeaf(page)

#define GistTupleIsInvalid(itup)

void gistdentryinit(GISTSTATE *giststate, int nkey, GISTENTRY *e, Datum k, Relation r, Page pg, OffsetNumber o, bool l, bool isNull)

Assert(PointerIsAligned(start, uint64))

static Datum index_getattr(IndexTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)

static bool DatumGetBool(Datum X)

static Datum PointerGetDatum(const void *X)

static Datum Int16GetDatum(int16 X)

static float8 DatumGetFloat8(Datum X)

static Datum ObjectIdGetDatum(Oid X)

IndexOrderByDistance * distances

struct ScanKeyData * keyData

struct ScanKeyData * orderByData

References Assert(), DatumGetBool(), DatumGetFloat8(), GISTScanOpaqueData::distances, elog, ERROR, FunctionCall5Coll(), get_float8_infinity(), gistdentryinit(), GistPageIsLeaf, GISTScanOpaqueData::giststate, GistTupleIsInvalid, i, if(), index_getattr(), IndexScanDescData::indexRelation, Int16GetDatum(), IndexOrderByDistance::isnull, sort-test::key, IndexScanDescData::keyData, IndexScanDescData::numberOfKeys, IndexScanDescData::numberOfOrderBys, ObjectIdGetDatum(), IndexScanDescData::opaque, IndexScanDescData::orderByData, PointerGetDatum(), SK_ISNULL, SK_SEARCHNOTNULL, SK_SEARCHNULL, test(), and IndexOrderByDistance::value.

Referenced by gistScanPage().

◆ gistkillitems()

Definition at line 38 of file gistget.c.

39{

45 int i;

46 bool killedsomething = false;

54 return;

66 {

68 so->numKilled = 0;

69 return;

70 }

79 {

83 killedsomething = true;

84 }

86 if (killedsomething)

87 {

90 }

99}

XLogRecPtr BufferGetLSNAtomic(Buffer buffer)

void UnlockReleaseBuffer(Buffer buffer)

void LockBuffer(Buffer buffer, int mode)

void MarkBufferDirtyHint(Buffer buffer, bool buffer_std)

Buffer ReadBuffer(Relation reln, BlockNumber blockNum)

static Page BufferGetPage(Buffer buffer)

static bool BufferIsValid(Buffer bufnum)

static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)

#define GistMarkPageHasGarbage(page)

void gistcheckpage(Relation rel, Buffer buf)

#define ItemIdMarkDead(itemId)

#define XLogRecPtrIsInvalid(r)

References Assert(), BufferGetLSNAtomic(), BufferGetPage(), BufferIsValid(), GISTScanOpaqueData::curBlkno, GISTScanOpaqueData::curPageLSN, GIST_SHARE, gistcheckpage(), GistMarkPageHasGarbage, GistPageIsLeaf, i, IndexScanDescData::indexRelation, InvalidBlockNumber, ItemIdMarkDead, GISTScanOpaqueData::killedItems, LockBuffer(), MarkBufferDirtyHint(), GISTScanOpaqueData::numKilled, IndexScanDescData::opaque, PageGetItemId(), ReadBuffer(), UnlockReleaseBuffer(), and XLogRecPtrIsInvalid.

Referenced by gistgettuple().

◆ gistScanPage()

Definition at line 328 of file gistget.c.

330{

340

342

349

350

351

352

353

354

355

360 {

361

363

364

365 Assert(myDistances != NULL);

366

368

369

371 item->blkno = opaque->rightlink;

373

374

375 memcpy(item->distances, myDistances,

377

379

381 }

382

383

384

385

386

387

388

389

390

392 {

394 return;

395 }

396

398 scan->xs_hitup = NULL;

401

402

403

404

405

406

408

409

410

411

414 {

417 bool match;

418 bool recheck;

419 bool recheck_distances;

420

421

422

423

424

426 continue;

427

429

430

431

432

433

435

437 &recheck, &recheck_distances);

438

441

442

443 if (!match)

444 continue;

445

447 {

448

449

450

451

453 (*ntids)++;

454 }

456 {

457

458

459

463

464

465

466

467

469 {

474 }

476 }

477 else

478 {

479

480

481

482

483

486

488

489

491

493 {

494

499

500

501

502

505 }

506 else

507 {

508

510

511

512

513

514

515

517 }

518

519

521 sizeof(item->distances[0]) * nOrderBys);

522

524

526 }

527 }

528

530}

BlockNumber BufferGetBlockNumber(Buffer buffer)

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

static OffsetNumber PageGetMaxOffsetNumber(const PageData *page)

#define GistFollowRight(page)

#define GistPageIsDeleted(page)

#define GistPageGetOpaque(page)

#define GistPageGetNSN(page)

#define SizeOfGISTSearchItem(n_distances)

static bool gistindex_keytest(IndexScanDesc scan, IndexTuple tuple, Page page, OffsetNumber offset, bool *recheck_p, bool *recheck_distances_p)

HeapTuple gistFetchTuple(GISTSTATE *giststate, Relation r, IndexTuple tuple)

#define ItemIdIsDead(itemId)

static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)

IndexTupleData * IndexTuple

#define OffsetNumberNext(offsetNumber)

#define FirstOffsetNumber

void pairingheap_add(pairingheap *heap, pairingheap_node *node)

void PredicateLockPage(Relation relation, BlockNumber blkno, Snapshot snapshot)

bool ignore_killed_tuples

struct SnapshotData * xs_snapshot

void tbm_add_tuples(TIDBitmap *tbm, const ItemPointer tids, int ntids, bool recheck)

Referenced by getNextNearest(), gistgetbitmap(), and gistgettuple().