PostgreSQL Source Code: src/backend/executor/nodeBitmapIndexscan.c Source File (original) (raw)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

23

29

30

31

32

33

34

35

36

39{

40 elog(ERROR, "BitmapIndexScan node does not support ExecProcNode call convention");

41 return NULL;

42}

43

44

45

46

47

50{

53 double nTuples = 0;

54 bool doscan;

55

56

59

60

61

62

64

65

66

67

68

69

70

73 {

75 doscan = node->biss_RuntimeKeysReady;

76 }

77 else

78 doscan = true;

79

80

81

82

83

84

85

87 {

89 node->biss_result = NULL;

90 }

91 else

92 {

93

97 }

98

99

100

101

102 while (doscan)

103 {

105

107

110 if (doscan)

113 NULL, 0);

114 }

115

116

119

120 return (Node *) tbm;

121}

122

123

124

125

126

127

128

129

130void

132{

134

135

136

137

138

139

140 if (econtext)

142

143

144

145

146

147

148

149

150

160 else

162

163

167 NULL, 0);

168}

169

170

171

172

173

174void

176{

179

180

181

182

185

186

187

188

189

190

192 {

194

195 Assert(ParallelWorkerNumber <= node->biss_SharedInfo->num_workers);

197

198

199

200

201

202

203

205 }

206

207

208

209

210 if (indexScanDesc)

212 if (indexRelationDesc)

214}

215

216

217

218

219

220

221

224{

227

228

230

231

232

233

236 indexstate->ss.ps.state = estate;

238

239

241

242

243

244

245

246

247

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

273 return indexstate;

274

275

278

279

280

281

285

286

287

288

292 false,

299

300

301

302

303

304

305

308 {

310

314 }

315 else

316 {

318 }

319

320

321

322

328

329

330

331

332

337 NULL, 0);

338

339

340

341

342 return indexstate;

343}

344

345

346

347

348

349

350

351

352void

354{

356

357

358

359

360

362 return;

363

368}

369

370

371

372

373

374

375

376void

379{

381

382

384 return;

385

390 size);

393

394

397}

398

399

400

401

402

403

404

405void

408{

409

411 return;

412

415}

416

417

418

419

420

421

422

423void

425{

427 size_t size;

428

429 if (SharedInfo == NULL)

430 return;

431

432

437}

void ExecReScan(PlanState *node)

void ExecAssignExprContext(EState *estate, PlanState *planstate)

#define EXEC_FLAG_BACKWARD

static RangeTblEntry * exec_rt_fetch(Index rti, EState *estate)

#define ResetExprContext(econtext)

#define EXEC_FLAG_EXPLAIN_ONLY

struct IndexScanInstrumentation IndexScanInstrumentation

Assert(PointerIsAligned(start, uint64))

#define IsParallelWorker()

void index_close(Relation relation, LOCKMODE lockmode)

void index_endscan(IndexScanDesc scan)

IndexScanDesc index_beginscan_bitmap(Relation indexRelation, Snapshot snapshot, IndexScanInstrumentation *instrument, int nkeys)

Relation index_open(Oid relationId, LOCKMODE lockmode)

int64 index_getbitmap(IndexScanDesc scan, TIDBitmap *bitmap)

void index_rescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys, int norderbys)

void InstrStartNode(Instrumentation *instr)

void InstrStopNode(Instrumentation *instr, double nTuples)

#define CHECK_FOR_INTERRUPTS()

void ExecBitmapIndexScanEstimate(BitmapIndexScanState *node, ParallelContext *pcxt)

Node * MultiExecBitmapIndexScan(BitmapIndexScanState *node)

void ExecEndBitmapIndexScan(BitmapIndexScanState *node)

void ExecBitmapIndexScanInitializeDSM(BitmapIndexScanState *node, ParallelContext *pcxt)

BitmapIndexScanState * ExecInitBitmapIndexScan(BitmapIndexScan *node, EState *estate, int eflags)

void ExecReScanBitmapIndexScan(BitmapIndexScanState *node)

void ExecBitmapIndexScanRetrieveInstrumentation(BitmapIndexScanState *node)

static TupleTableSlot * ExecBitmapIndexScan(PlanState *pstate)

void ExecBitmapIndexScanInitializeWorker(BitmapIndexScanState *node, ParallelWorkerContext *pwcxt)

void ExecIndexBuildScanKeys(PlanState *planstate, Relation index, List *quals, bool isorderby, ScanKey *scanKeys, int *numScanKeys, IndexRuntimeKeyInfo **runtimeKeys, int *numRuntimeKeys, IndexArrayKeyInfo **arrayKeys, int *numArrayKeys)

bool ExecIndexEvalArrayKeys(ExprContext *econtext, IndexArrayKeyInfo *arrayKeys, int numArrayKeys)

void ExecIndexEvalRuntimeKeys(ExprContext *econtext, IndexRuntimeKeyInfo *runtimeKeys, int numRuntimeKeys)

bool ExecIndexAdvanceArrayKeys(IndexArrayKeyInfo *arrayKeys, int numArrayKeys)

void * shm_toc_allocate(shm_toc *toc, Size nbytes)

void shm_toc_insert(shm_toc *toc, uint64 key, void *address)

void * shm_toc_lookup(shm_toc *toc, uint64 key, bool noError)

#define shm_toc_estimate_chunk(e, sz)

#define shm_toc_estimate_keys(e, cnt)

bool biss_RuntimeKeysReady

ExprContext * biss_RuntimeContext

IndexArrayKeyInfo * biss_ArrayKeys

IndexRuntimeKeyInfo * biss_RuntimeKeys

SharedIndexScanInstrumentation * biss_SharedInfo

struct ScanKeyData * biss_ScanKeys

struct IndexScanDescData * biss_ScanDesc

Relation biss_RelationDesc

IndexScanInstrumentation biss_Instrument

struct dsa_area * es_query_dsa

shm_toc_estimator estimator

Instrumentation * instrument

ExprContext * ps_ExprContext

ExecProcNodeMtd ExecProcNode

Relation ss_currentRelation

struct TableScanDescData * ss_currentScanDesc

TIDBitmap * tbm_create(Size maxbytes, dsa_area *dsa)