448 errhint("The index is not optimal. To optimize it, contact a developer, or try to use the column as the second one in the CREATE INDEX command.")));

449

450 /*

451 * Reinit GIST_SPLITVEC. Although these fields are not used by

452 * genericPickSplit(), set them up for further processing

453 */

454 sv->spl_ldatum_exists = !(v->spl_lisnull[attno]);

455 sv->spl_rdatum_exists = !(v->spl_risnull[attno]);

456 sv->spl_ldatum = v->spl_lattr[attno];

457 sv->spl_rdatum = v->spl_rattr[attno];

458

459 /* Do a generic split */

460 genericPickSplit(giststate, entryvec, sv, attno);

461 }

462 else

463 {

464 /* hack for compatibility with old picksplit API */

465 if (sv->spl_left[sv->spl_nleft - 1] == InvalidOffsetNumber)

466 sv->spl_left[sv->spl_nleft - 1] = (OffsetNumber) (entryvec->n - 1);

467 if (sv->spl_right[sv->spl_nright - 1] == InvalidOffsetNumber)

468 sv->spl_right[sv->spl_nright - 1] = (OffsetNumber) (entryvec->n - 1);

469 }

470

471 /* Clean up if PickSplit didn't take care of a secondary split */

472 if (sv->spl_ldatum_exists || sv->spl_rdatum_exists)

473 supportSecondarySplit(r, giststate, attno, sv,

474 v->spl_lattr[attno], v->spl_rattr[attno]);

475

476 /* emit union datums computed by PickSplit back to v arrays */

477 v->spl_lattr[attno] = sv->spl_ldatum;

478 v->spl_rattr[attno] = sv->spl_rdatum;

479 v->spl_lisnull[attno] = false;

480 v->spl_risnull[attno] = false;

481

482 /*

483 * If index columns remain, then consider whether we can improve the split

484 * by using them.

485 */

486 v->spl_dontcare = NULL;

487

488 if (attno + 1 < giststate->nonLeafTupdesc->natts)

489 {

490 int NumDontCare;

491

492 /*

493 * Make a quick check to see if left and right union keys are equal;

494 * if so, the split is certainly degenerate, so tell caller to

495 * re-split with the next column.

496 */

497 if (gistKeyIsEQ(giststate, attno, sv->spl_ldatum, sv->spl_rdatum))

498 return true;

499

500 /*

501 * Locate don't-care tuples, if any. If there are none, the split is

502 * optimal, so just fall out and return false.

503 */

504 v->spl_dontcare = (bool *) palloc0(sizeof(bool) * (entryvec->n + 1));

505

506 NumDontCare = findDontCares(r, giststate, entryvec->vector, v, attno);

507

508 if (NumDontCare > 0)

509 {

510 /*

511 * Remove don't-cares from spl_left[] and spl_right[].

512 */

513 removeDontCares(sv->spl_left, &sv->spl_nleft, v->spl_dontcare);

514 removeDontCares(sv->spl_right, &sv->spl_nright, v->spl_dontcare);

515

516 /*

517 * If all tuples on either side were don't-cares, the split is

518 * degenerate, and we're best off to ignore it and split on the

519 * next column. (We used to try to press on with a secondary

520 * split by forcing a random tuple on each side to be treated as

521 * non-don't-care, but it seems unlikely that that technique

522 * really gives a better result. Note that we don't want to try a

523 * secondary split with empty left or right primary split sides,

524 * because then there is no union key on that side for the

525 * PickSplit function to try to expand, so it can have no good

526 * figure of merit for what it's doing. Also note that this check

527 * ensures we can't produce a bogus one-side-only split in the

528 * NumDontCare == 1 special case below.)

529 */

530 if (sv->spl_nleft == 0 || sv->spl_nright == 0)

531 {

532 v->spl_dontcare = NULL;

533 return true;

534 }

535

536 /*

537 * Recompute union keys, considering only non-don't-care tuples.

538 * NOTE: this will set union keys for remaining index columns,

539 * which will cause later calls of gistUserPicksplit to pass those

540 * values down to user-defined PickSplit methods with

541 * spl_ldatum_exists/spl_rdatum_exists set true.

542 */

543 gistunionsubkey(giststate, itup, v);

544

545 if (NumDontCare == 1)

546 {

547 /*

548 * If there's only one don't-care tuple then we can't do a

549 * PickSplit on it, so just choose whether to send it left or

550 * right by comparing penalties. We needed the

551 * gistunionsubkey step anyway so that we have appropriate

552 * union keys for figuring the penalties.

553 */

554 OffsetNumber toMove;

555

556 /* find it ... */

557 for (toMove = FirstOffsetNumber; toMove < entryvec->n; toMove++)

558 {

559 if (v->spl_dontcare[toMove])

560 break;

561 }

562 Assert(toMove < entryvec->n);

563

564 /* ... and assign it to cheaper side */

565 placeOne(r, giststate, v, itup[toMove - 1], toMove, attno + 1);

566

567 /*

568 * At this point the union keys are wrong, but we don't care

569 * because we're done splitting. The outermost recursion

570 * level of gistSplitByKey will fix things before returning.

571 */

572 }

573 else

574 return true;

575 }

576 }

577

578 return false;

579}

errhint

int errhint(const char *fmt,...)

Definition: elog.c:1321

errcode

int errcode(int sqlerrcode)

Definition: elog.c:854

errmsg

int errmsg(const char *fmt,...)

Definition: elog.c:1071

DEBUG1

#define DEBUG1

Definition: elog.h:30

ereport

#define ereport(elevel,...)

Definition: elog.h:150

removeDontCares

static void removeDontCares(OffsetNumber *a, int *len, const bool *dontcare)

Definition: gistsplit.c:167

supportSecondarySplit

static void supportSecondarySplit(Relation r, GISTSTATE *giststate, int attno, GIST_SPLITVEC *sv, Datum oldL, Datum oldR)

Definition: gistsplit.c:258

genericPickSplit

static void genericPickSplit(GISTSTATE *giststate, GistEntryVector *entryvec, GIST_SPLITVEC *v, int attno)

Definition: gistsplit.c:344

placeOne

static void placeOne(Relation r, GISTSTATE *giststate, GistSplitVector *v, IndexTuple itup, OffsetNumber off, int attno)

Definition: gistsplit.c:200

findDontCares

static int findDontCares(Relation r, GISTSTATE *giststate, GISTENTRY *valvec, GistSplitVector *spl, int attno)

Definition: gistsplit.c:113

gistKeyIsEQ

bool gistKeyIsEQ(GISTSTATE *giststate, int attno, Datum a, Datum b)

Definition: gistutil.c:281

palloc0

void * palloc0(Size size)

Definition: mcxt.c:1395

InvalidOffsetNumber

#define InvalidOffsetNumber

Definition: off.h:26

RelationGetRelationName

#define RelationGetRelationName(relation)

Definition: rel.h:548

GISTSTATE::picksplitFn

FmgrInfo picksplitFn[INDEX_MAX_KEYS]

Definition: gist_private.h:91

GIST_SPLITVEC::spl_ldatum_exists

bool spl_ldatum_exists

Definition: gist.h:146

GIST_SPLITVEC::spl_rdatum_exists

bool spl_rdatum_exists

Definition: gist.h:151

Referenced by gistSplitByKey().

◆ placeOne()

static void placeOne ( Relation r,

GISTSTATE * giststate,

GistSplitVector * v,

IndexTuple itup,

OffsetNumber off,

int attno

)

static

Definition at line 200 of file gistsplit.c.

202{

203 GISTENTRY identry[INDEX_MAX_KEYS];

204 bool isnull[INDEX_MAX_KEYS];

205 bool toLeft = true;

206

207 gistDeCompressAtt(giststate, r, itup, NULL, (OffsetNumber) 0,

208 identry, isnull);

209

210 for (; attno < giststate->nonLeafTupdesc->natts; attno++)

211 {

212 float lpenalty,

213 rpenalty;

214 GISTENTRY entry;

215

216 gistentryinit(entry, v->spl_lattr[attno], r, NULL, 0, false);

217 lpenalty = gistpenalty(giststate, attno, &entry, v->spl_lisnull[attno],

218 identry + attno, isnull[attno]);

219 gistentryinit(entry, v->spl_rattr[attno], r, NULL, 0, false);

220 rpenalty = gistpenalty(giststate, attno, &entry, v->spl_risnull[attno],

221 identry + attno, isnull[attno]);

222

223 if (lpenalty != rpenalty)

224 {

225 if (lpenalty > rpenalty)

226 toLeft = false;

227 break;

228 }

229 }

230

231 if (toLeft)

232 v->splitVector.spl_left[v->splitVector.spl_nleft++] = off;

233 else

234 v->splitVector.spl_right[v->splitVector.spl_nright++] = off;

235}

gistDeCompressAtt

void gistDeCompressAtt(GISTSTATE *giststate, Relation r, IndexTuple tuple, Page p, OffsetNumber o, GISTENTRY *attdata, bool *isnull)

Definition: gistutil.c:296

INDEX_MAX_KEYS

#define INDEX_MAX_KEYS

Definition: pg_config_manual.h:69

References gistDeCompressAtt(), gistentryinit, gistpenalty(), INDEX_MAX_KEYS, TupleDescData::natts, GISTSTATE::nonLeafTupdesc, GistSplitVector::spl_lattr, GIST_SPLITVEC::spl_left, GistSplitVector::spl_lisnull, GIST_SPLITVEC::spl_nleft, GIST_SPLITVEC::spl_nright, GistSplitVector::spl_rattr, GIST_SPLITVEC::spl_right, GistSplitVector::spl_risnull, and GistSplitVector::splitVector.

Referenced by gistUserPicksplit().

◆ removeDontCares()

static void removeDontCares ( OffsetNumber * a,

int * len,

const bool * dontcare

)

static

Definition at line 167 of file gistsplit.c.

168{

169 int origlen,

170 newlen,

171 i;

172 OffsetNumber *curwpos;

173

174 origlen = newlen = *len;

175 curwpos = a;

176 for (i = 0; i < origlen; i++)

177 {

178 OffsetNumber ai = a[i];

179

180 if (dontcare[ai] == false)

181 {

182 /* re-emit item into a[] */

183 *curwpos = ai;

184 curwpos++;

185 }

186 else

187 newlen--;

188 }

189

190 *len = newlen;

191}

a

int a

Definition: isn.c:73

References a, i, and len.

Referenced by gistUserPicksplit().

◆ supportSecondarySplit()

static void supportSecondarySplit ( Relation r,

GISTSTATE * giststate,

int attno,

GIST_SPLITVEC * sv,

Datum oldL,

Datum oldR

)

static

Definition at line 258 of file gistsplit.c.

260{

261 bool leaveOnLeft = true,

262 tmpBool;

263 GISTENTRY entryL,

264 entryR,

265 entrySL,

266 entrySR;

267

268 gistentryinit(entryL, oldL, r, NULL, 0, false);

269 gistentryinit(entryR, oldR, r, NULL, 0, false);

270 gistentryinit(entrySL, sv->spl_ldatum, r, NULL, 0, false);

271 gistentryinit(entrySR, sv->spl_rdatum, r, NULL, 0, false);

272

273 if (sv->spl_ldatum_exists && sv->spl_rdatum_exists)

274 {

275 float penalty1,

276 penalty2;

277

278 penalty1 = gistpenalty(giststate, attno, &entryL, false, &entrySL, false) +

279 gistpenalty(giststate, attno, &entryR, false, &entrySR, false);

280 penalty2 = gistpenalty(giststate, attno, &entryL, false, &entrySR, false) +

281 gistpenalty(giststate, attno, &entryR, false, &entrySL, false);

282

283 if (penalty1 > penalty2)

284 leaveOnLeft = false;

285 }

286 else

287 {

288 GISTENTRY *entry1 = (sv->spl_ldatum_exists) ? &entryL : &entryR;

289 float penalty1,

290 penalty2;

291

292 /*

293 * There is only one previously defined union, so we just choose swap

294 * or not by lowest penalty for that side. We can only get here if a

295 * secondary split happened to have all NULLs in its column in the

296 * tuples that the outer recursion level had assigned to one side.

297 * (Note that the null checks in gistSplitByKey don't prevent the

298 * case, because they'll only be checking tuples that were considered

299 * don't-cares at the outer recursion level, not the tuples that went

300 * into determining the passed-down left and right union keys.)

301 */

302 penalty1 = gistpenalty(giststate, attno, entry1, false, &entrySL, false);

303 penalty2 = gistpenalty(giststate, attno, entry1, false, &entrySR, false);

304

305 if (penalty1 < penalty2)

306 leaveOnLeft = sv->spl_ldatum_exists;

307 else

308 leaveOnLeft = sv->spl_rdatum_exists;

309 }

310

311 if (leaveOnLeft == false)

312 {

313 /*

314 * swap left and right

315 */

316 OffsetNumber *off,

317 noff;

318 Datum datum;

319

320 SWAPVAR(sv->spl_left, sv->spl_right, off);

321 SWAPVAR(sv->spl_nleft, sv->spl_nright, noff);

322 SWAPVAR(sv->spl_ldatum, sv->spl_rdatum, datum);

323 gistentryinit(entrySL, sv->spl_ldatum, r, NULL, 0, false);

324 gistentryinit(entrySR, sv->spl_rdatum, r, NULL, 0, false);

325 }

326

327 if (sv->spl_ldatum_exists)

328 gistMakeUnionKey(giststate, attno, &entryL, false, &entrySL, false,

329 &sv->spl_ldatum, &tmpBool);

330

331 if (sv->spl_rdatum_exists)

332 gistMakeUnionKey(giststate, attno, &entryR, false, &entrySR, false,

333 &sv->spl_rdatum, &tmpBool);

334

335 sv->spl_ldatum_exists = sv->spl_rdatum_exists = false;

336}

SWAPVAR

#define SWAPVAR(s, d, t)

Definition: gistsplit.c:237

gistMakeUnionKey

void gistMakeUnionKey(GISTSTATE *giststate, int attno, GISTENTRY *entry1, bool isnull1, GISTENTRY *entry2, bool isnull2, Datum *dst, bool *dstisnull)

Definition: gistutil.c:233

References gistentryinit, gistMakeUnionKey(), gistpenalty(), GIST_SPLITVEC::spl_ldatum, GIST_SPLITVEC::spl_ldatum_exists, GIST_SPLITVEC::spl_left, GIST_SPLITVEC::spl_nleft, GIST_SPLITVEC::spl_nright, GIST_SPLITVEC::spl_rdatum, GIST_SPLITVEC::spl_rdatum_exists, GIST_SPLITVEC::spl_right, and SWAPVAR.

Referenced by gistUserPicksplit().