PostgreSQL Source Code: src/include/executor/execPartition.h File Reference (original) (raw)

Go to the source code of this file.

◆ PartitionDispatch

◆ PartitionedRelPruningData

◆ PartitionPruneState

◆ PartitionPruningData

◆ PartitionTupleRouting

◆ ExecCleanupTupleRouting()

Definition at line 1237 of file execPartition.c.

1239{

1240 int i;

1241

1242

1243

1244

1245

1246

1247

1248

1250 {

1252

1254

1257 }

1258

1260 {

1262

1263

1267 resultRelInfo);

1268

1269

1270

1271

1272

1274 continue;

1275

1278 }

1279}

void ExecCloseIndices(ResultRelInfo *resultRelInfo)

void ExecDropSingleTupleTableSlot(TupleTableSlot *slot)

EndForeignInsert_function EndForeignInsert

PartitionDispatch * partition_dispatch_info

ResultRelInfo ** partitions

struct FdwRoutine * ri_FdwRoutine

void table_close(Relation relation, LOCKMODE lockmode)

References FdwRoutine::EndForeignInsert, ExecCloseIndices(), ExecDropSingleTupleTableSlot(), i, PartitionTupleRouting::is_borrowed_rel, NoLock, PartitionTupleRouting::num_dispatch, PartitionTupleRouting::num_partitions, PartitionTupleRouting::partition_dispatch_info, PartitionTupleRouting::partitions, ModifyTableState::ps, PartitionDispatchData::reldesc, ResultRelInfo::ri_FdwRoutine, ResultRelInfo::ri_RelationDesc, PlanState::state, table_close(), and PartitionDispatchData::tupslot.

Referenced by CopyFrom(), ExecEndModifyTable(), and finish_edata().

◆ ExecDoInitialPruning()

Definition at line 1822 of file execPartition.c.

1823{

1826 List *locked_relids = NIL;

1827

1829 {

1832 Bitmapset *validsubplans = NULL;

1833 Bitmapset *all_leafpart_rtis = NULL;

1834 Bitmapset *validsubplan_rtis = NULL;

1835

1836

1838 &all_leafpart_rtis);

1840 prunestate);

1841

1842

1843

1844

1845

1848 &validsubplan_rtis);

1849 else

1850 validsubplan_rtis = all_leafpart_rtis;

1851

1853 {

1854 int rtindex = -1;

1855

1857 rtindex)) >= 0)

1858 {

1860

1862 rte->rellockmode != NoLock);

1864 locked_relids = lappend_int(locked_relids, rtindex);

1865 }

1866 }

1868 validsubplan_rtis);

1870 validsubplans);

1871 }

1872

1873

1874

1875

1876

1877

1878

1879

1880

1881

1882

1883

1885 {

1886 foreach(lc, stmt->firstResultRels)

1887 {

1889

1891 {

1893

1896 locked_relids = lappend_int(locked_relids, firstResultRel);

1897 }

1898 }

1899 }

1900

1901

1902

1903

1904

1906 {

1907 foreach(lc, locked_relids)

1908 {

1910

1912 }

1913 }

1914}

int bms_next_member(const Bitmapset *a, int prevbit)

bool bms_is_member(int x, const Bitmapset *a)

Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)

Bitmapset * ExecFindMatchingSubPlans(PartitionPruneState *prunestate, bool initial_prune, Bitmapset **validsubplan_rtis)

static PartitionPruneState * CreatePartitionPruneState(EState *estate, PartitionPruneInfo *pruneinfo, Bitmapset **all_leafpart_rtis)

static bool ExecShouldLockRelations(EState *estate)

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

static bool ExecPlanStillValid(EState *estate)

Assert(PointerIsAligned(start, uint64))

List * lappend(List *list, void *datum)

List * lappend_int(List *list, int datum)

void UnlockRelationOid(Oid relid, LOCKMODE lockmode)

void LockRelationOid(Oid relid, LOCKMODE lockmode)

#define lfirst_node(type, lc)

List * es_part_prune_infos

PlannedStmt * es_plannedstmt

Bitmapset * es_unpruned_relids

List * es_part_prune_states

List * es_part_prune_results

References Assert(), bms_add_members(), bms_is_member(), bms_next_member(), CreatePartitionPruneState(), PartitionPruneState::do_initial_prune, EState::es_part_prune_infos, EState::es_part_prune_results, EState::es_part_prune_states, EState::es_plannedstmt, EState::es_unpruned_relids, exec_rt_fetch(), ExecFindMatchingSubPlans(), ExecPlanStillValid(), ExecShouldLockRelations(), lappend(), lappend_int(), lfirst_int, lfirst_node, LockRelationOid(), NIL, NoLock, RTE_RELATION, RangeTblEntry::rtekind, stmt, and UnlockRelationOid().

Referenced by InitPlan().

◆ ExecFindMatchingSubPlans()

Definition at line 2555 of file execPartition.c.

2558{

2561 int i;

2562

2563

2564

2565

2566

2567

2569 Assert(validsubplan_rtis != NULL || !initial_prune);

2570

2571

2572

2573

2574

2576

2577

2578

2579

2580

2582 {

2585

2586

2587

2588

2589

2590

2593 &result, validsubplan_rtis);

2594

2595

2596

2597

2598

2599

2602 }

2603

2604

2606

2608

2609

2611 if (validsubplan_rtis)

2612 *validsubplan_rtis = bms_copy(*validsubplan_rtis);

2613

2615

2616 return result;

2617}

Bitmapset * bms_copy(const Bitmapset *a)

static void find_matching_subplans_recurse(PartitionPruningData *prunedata, PartitionedRelPruningData *pprune, bool initial_prune, Bitmapset **validsubplans, Bitmapset **validsubplan_rtis)

#define ResetExprContext(econtext)

void MemoryContextReset(MemoryContext context)

static MemoryContext MemoryContextSwitchTo(MemoryContext context)

ExprContext * exprcontext

PartitionPruningData * partprunedata[FLEXIBLE_ARRAY_MEMBER]

Bitmapset * other_subplans

MemoryContext prune_context

PartitionedRelPruningData partrelprunedata[FLEXIBLE_ARRAY_MEMBER]

List * exec_pruning_steps

PartitionPruneContext exec_context

References Assert(), bms_add_members(), bms_copy(), PartitionPruneState::do_exec_prune, PartitionedRelPruningData::exec_context, PartitionedRelPruningData::exec_pruning_steps, PartitionPruneContext::exprcontext, find_matching_subplans_recurse(), i, MemoryContextReset(), MemoryContextSwitchTo(), PartitionPruneState::num_partprunedata, PartitionPruneState::other_subplans, PartitionPruneState::partprunedata, PartitionPruningData::partrelprunedata, PartitionPruneState::prune_context, and ResetExprContext.

Referenced by choose_next_subplan_for_leader(), choose_next_subplan_for_worker(), choose_next_subplan_locally(), ExecAppendAsyncBegin(), ExecDoInitialPruning(), and ExecMergeAppend().

◆ ExecFindPartition()

Definition at line 266 of file execPartition.c.

270{

283

284

286

287

288

289

290

293

294

295 dispatch = pd[0];

296 while (dispatch != NULL)

297 {

298 int partidx = -1;

299 bool is_leaf;

300

302

304 partdesc = dispatch->partdesc;

305

306

307

308

309

310

311

312

313

316

317

318

319

320

321 if (partdesc->nparts == 0 ||

323 {

324 char *val_desc;

325

330 (errcode(ERRCODE_CHECK_VIOLATION),

331 errmsg("no partition of relation \"%s\" found for row",

333 val_desc ?

334 errdetail("Partition key of the failing row contains %s.",

335 val_desc) : 0,

337 }

338

339 is_leaf = partdesc->is_leaf[partidx];

340 if (is_leaf)

341 {

342

343

344

345

347 {

348

351 }

352 else

353 {

354

355

356

357

358

360 partdesc->oids[partidx],

361 true, false);

362 if (rri)

363 {

364

366

367

368

369

370

372 rri, partidx, true);

373 }

374 else

375 {

376

378 dispatch,

379 rootResultRelInfo, partidx);

380 }

381 }

383

384

385 dispatch = NULL;

386 }

387 else

388 {

389

390

391

393 {

394

396

398

399

400

401

402

403 dispatch = pd[dispatch->indexes[partidx]];

404 }

405 else

406 {

407

409

410

411

412

413

415 proute,

416 partdesc->oids[partidx],

417 dispatch, partidx,

421

423 dispatch = subdispatch;

424 }

425

426

427

428

429

431 {

434

435 myslot = dispatch->tupslot;

437

438 if (tempslot != NULL)

440 }

441 }

442

443

444

445

446

447

448

449

450

452 {

453

454

455

456

457

458

459

460

461

462

463

464

465 if (is_leaf)

466 {

468

469 if (map)

472 else

473 slot = rootslot;

474 }

475

477 }

478 }

479

480

481 if (myslot != NULL)

483

486

487 return rri;

488}

static Datum values[MAXATTR]

#define OidIsValid(objectId)

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

int errcode(int sqlerrcode)

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

#define ereport(elevel,...)

void CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation, List *mergeActions)

bool ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate, bool emitError)

static PartitionDispatch ExecInitPartitionDispatchInfo(EState *estate, PartitionTupleRouting *proute, Oid partoid, PartitionDispatch parent_pd, int partidx, ResultRelInfo *rootResultRelInfo)

static ResultRelInfo * ExecInitPartitionInfo(ModifyTableState *mtstate, EState *estate, PartitionTupleRouting *proute, PartitionDispatch dispatch, ResultRelInfo *rootResultRelInfo, int partidx)

static void ExecInitRoutingInfo(ModifyTableState *mtstate, EState *estate, PartitionTupleRouting *proute, PartitionDispatch dispatch, ResultRelInfo *partRelInfo, int partidx, bool is_borrowed_rel)

static char * ExecBuildSlotPartitionKeyDescription(Relation rel, Datum *values, bool *isnull, int maxfieldlen)

static void FormPartitionKeyDatum(PartitionDispatch pd, TupleTableSlot *slot, EState *estate, Datum *values, bool *isnull)

static int get_partition_for_tuple(PartitionDispatch pd, Datum *values, bool *isnull)

TupleConversionMap * ExecGetRootToChildMap(ResultRelInfo *resultRelInfo, EState *estate)

#define GetPerTupleExprContext(estate)

#define GetPerTupleMemoryContext(estate)

#define CHECK_FOR_INTERRUPTS()

ResultRelInfo * ExecLookupResultRelByOid(ModifyTableState *node, Oid resultoid, bool missing_ok, bool update_cache)

#define PARTITION_MAX_KEYS

#define RelationGetRelid(relation)

#define RelationGetRelationName(relation)

int errtable(Relation rel)

TupleTableSlot * ecxt_scantuple

ResultRelInfo * rootResultRelInfo

PartitionBoundInfo boundinfo

int indexes[FLEXIBLE_ARRAY_MEMBER]

ResultRelInfo ** nonleaf_partitions

TupleTableSlot * ri_PartitionTupleSlot

TupleTableSlot * execute_attr_map_slot(AttrMap *attrMap, TupleTableSlot *in_slot, TupleTableSlot *out_slot)

static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)

References Assert(), TupleConversionMap::attrMap, PartitionDescData::boundinfo, CHECK_FOR_INTERRUPTS, CheckValidResultRel(), CMD_INSERT, PartitionBoundInfoData::default_index, ExprContext::ecxt_scantuple, ereport, errcode(), errdetail(), errmsg(), ERROR, errtable(), ExecBuildSlotPartitionKeyDescription(), ExecClearTuple(), ExecGetRootToChildMap(), ExecInitPartitionDispatchInfo(), ExecInitPartitionInfo(), ExecInitRoutingInfo(), ExecLookupResultRelByOid(), ExecPartitionCheck(), execute_attr_map_slot(), FormPartitionKeyDatum(), get_partition_for_tuple(), GetPerTupleExprContext, GetPerTupleMemoryContext, PartitionDispatchData::indexes, PartitionDescData::is_leaf, likely, MemoryContextSwitchTo(), NIL, PartitionTupleRouting::nonleaf_partitions, PartitionDescData::nparts, PartitionTupleRouting::num_dispatch, PartitionTupleRouting::num_partitions, OidIsValid, PartitionDescData::oids, PartitionDispatchData::partdesc, PartitionTupleRouting::partition_dispatch_info, PARTITION_MAX_KEYS, PartitionTupleRouting::partitions, RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, PartitionDispatchData::reldesc, ResultRelInfo::ri_PartitionTupleSlot, ResultRelInfo::ri_RelationDesc, ModifyTableState::rootResultRelInfo, PartitionDispatchData::tupmap, PartitionDispatchData::tupslot, and values.

Referenced by apply_handle_tuple_routing(), CopyFrom(), and ExecPrepareTupleRouting().

◆ ExecInitPartitionExecPruning()

Definition at line 1937 of file execPartition.c.

1942{

1946

1947

1949 part_prune_index);

1950

1951

1953 elog(ERROR, "wrong pruneinfo with relids=%s found at part_prune_index=%d contained in plan node with relids=%s",

1956

1957

1958

1959

1960

1961

1963 Assert(prunestate != NULL);

1964

1965

1969 part_prune_index);

1970 else

1971 {

1972

1973 Assert(n_total_subplans > 0);

1974 *initially_valid_subplans = bms_add_range(NULL, 0,

1975 n_total_subplans - 1);

1976 }

1977

1978

1979

1980

1981

1982

1983

1984

1985

1986

1987

1988

1989

1992 *initially_valid_subplans,

1993 n_total_subplans);

1994

1995 return prunestate;

1996}

bool bms_equal(const Bitmapset *a, const Bitmapset *b)

Bitmapset * bms_add_range(Bitmapset *a, int lower, int upper)

static void InitExecPartitionPruneContexts(PartitionPruneState *prunestate, PlanState *parent_plan, Bitmapset *initially_valid_subplans, int n_total_subplans)

char * bmsToString(const Bitmapset *bms)

static void * list_nth(const List *list, int n)

#define list_nth_node(type, list, n)

References Assert(), bms_add_range(), bms_equal(), bmsToString(), PartitionPruneState::do_exec_prune, PartitionPruneState::do_initial_prune, elog, ERROR, EState::es_part_prune_infos, EState::es_part_prune_results, EState::es_part_prune_states, InitExecPartitionPruneContexts(), list_nth(), list_nth_node, PartitionPruneInfo::relids, and PlanState::state.

Referenced by ExecInitAppend(), and ExecInitMergeAppend().

◆ ExecSetupPartitionTupleRouting()

Definition at line 219 of file execPartition.c.

220{

222

223

224

225

226

227

228

229

233

234

235

236

237

238

239

241 NULL, 0, NULL);

242

243 return proute;

244}

void * palloc0(Size size)

MemoryContext CurrentMemoryContext

References CurrentMemoryContext, ExecInitPartitionDispatchInfo(), PartitionTupleRouting::memcxt, palloc0(), PartitionTupleRouting::partition_root, and RelationGetRelid.

Referenced by apply_handle_tuple_routing(), CopyFrom(), ExecCrossPartitionUpdate(), ExecInitMerge(), and ExecInitModifyTable().