paramassign.c Source File (original) (raw)

65static int

67{

73 for (levelsup = var->varlevelsup; levelsup > 0; levelsup--)

77 foreach(ppl, root->plan_params)

78 {

81 {

91 pvar->vartype == var->vartype &&

92 pvar->vartypmod == var->vartypmod &&

93 pvar->varcollid == var->varcollid &&

95 bms_equal(pvar->varnullingrels, var->varnullingrels))

97 }

98 }

100

103

108 var->vartype);

109

111

113}

114

115

116

117

118

119

122{

124 int i;

125

127

128

130

134 retval->paramtype = var->vartype;

135 retval->paramtypmod = var->vartypmod;

136 retval->paramcollid = var->varcollid;

138

139 return retval;

140}

141

142

143

144

145

146

147

148

149static int

151{

155

156

157 for (levelsup = phv->phlevelsup; levelsup > 0; levelsup--)

159

160

161 foreach(ppl, root->plan_params)

162 {

165 {

167

168

171 }

172 }

173

174

178

184

186

188}

189

190

191

192

193

194

195

196

199{

201 int i;

202

204

205

207

212 retval->paramtypmod = exprTypmod((Node *) phv->phexpr);

215

216 return retval;

217}

218

219

220

221

222

223

226{

230

231 Assert(agg->agglevelsup > 0 && agg->agglevelsup < root->query_level);

232

233

234 for (levelsup = agg->agglevelsup; levelsup > 0; levelsup--)

236

237

238

239

240

243 Assert(agg->agglevelsup == 0);

244

249 agg->aggtype);

250

252

256 retval->paramtype = agg->aggtype;

257 retval->paramtypmod = -1;

258 retval->paramcollid = agg->aggcollid;

260

261 return retval;

262}

263

264

265

266

267

268

269

272{

277

279

280

281 for (levelsup = grp->agglevelsup; levelsup > 0; levelsup--)

283

284

285

286

287

291

296 ptype);

297

299

304 retval->paramtypmod = -1;

307

308 return retval;

309}

310

311

312

313

314

315

316

319{

323

325

326

327

328

329

330 do

331 {

333 if (root == NULL)

334 elog(ERROR, "MergeSupportFunc found outside MERGE");

336

337

338

339

340

342

347 ptype);

348

350

355 retval->paramtypmod = -1;

358

359 return retval;

360}

361

362

363

364

365

366

369{

374

376

377

378 for (levelsup = rexpr->retlevelsup; levelsup > 0; levelsup--)

380

381

382

383

384

388

390 pitem->item = (Node *) rexpr;

393 ptype);

394

396

404

405 return retval;

406}

407

408

409

410

411

412

415{

419

420

421 foreach(lc, root->curOuterParams)

422 {

425 {

426

431 param->paramtypmod = var->vartypmod;

432 param->paramcollid = var->varcollid;

434 return param;

435 }

436 }

437

438

440 var->vartype,

441 var->vartypmod,

442 var->varcollid);

444

445

449 root->curOuterParams = lappend(root->curOuterParams, nlp);

450

451

452 return param;

453}

454

455

456

457

458

459

460

461

464{

468

469

470 foreach(lc, root->curOuterParams)

471 {

474 {

475

480 param->paramtypmod = exprTypmod((Node *) phv->phexpr);

483 return param;

484 }

485 }

486

487

492

493

497 root->curOuterParams = lappend(root->curOuterParams, nlp);

498

499

500 return param;

501}

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526void

528{

530

531 foreach(lc, subplan_params)

532 {

534

536 {

540

541

543 elog(ERROR, "non-LATERAL parameter required by subquery");

544

545

546 foreach(lc2, root->curOuterParams)

547 {

549 if (nlp->paramno == pitem->paramId)

550 {

552

553 break;

554 }

555 }

556 if (lc2 == NULL)

557 {

558

560 nlp->paramno = pitem->paramId;

562 root->curOuterParams = lappend(root->curOuterParams, nlp);

563 }

564 }

566 {

570

571

573 root->curOuterRels))

574 elog(ERROR, "non-LATERAL parameter required by subquery");

575

576

577 foreach(lc2, root->curOuterParams)

578 {

580 if (nlp->paramno == pitem->paramId)

581 {

583

584 break;

585 }

586 }

587 if (lc2 == NULL)

588 {

589

591 nlp->paramno = pitem->paramId;

593 root->curOuterParams = lappend(root->curOuterParams, nlp);

594 }

595 }

596 else

597 elog(ERROR, "unexpected type of subquery parameter");

598 }

599}

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

630{

631 List *result;

633

634 result = NIL;

635 foreach(cell, root->curOuterParams)

636 {

638

639

640

641

642

643

644

647 {

649

651 cell);

652 var->varnullingrels = bms_intersect(var->varnullingrels,

653 leftrelids);

654 result = lappend(result, nlp);

655 }

659 leftrelids))

660 {

662

664 cell);

666 leftrelids);

667 result = lappend(result, nlp);

668 }

669 }

670 return result;

671}

672

673

674

675

676

677

678

679

680

681

682

685 Oid paramcollation)

686{

688

693 paramtype);

695 retval->paramtypmod = paramtypmod;

696 retval->paramcollid = paramcollation;

698

699 return retval;

700}

701

702

703

704

705

706

707

708

709

710int

712{

714

717 return paramId;

718}

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

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

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

bool bms_is_member(int x, const Bitmapset *a)

bool equal(const void *a, const void *b)

Assert(PointerIsAligned(start, uint64))

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

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

List * lappend_oid(List *list, Oid datum)

Oid exprType(const Node *expr)

int32 exprTypmod(const Node *expr)

Oid exprCollation(const Node *expr)

int exprLocation(const Node *expr)

#define IsA(nodeptr, _type_)

Param * replace_outer_merge_support(PlannerInfo *root, MergeSupportFunc *msf)

static int assign_param_for_var(PlannerInfo *root, Var *var)

static int assign_param_for_placeholdervar(PlannerInfo *root, PlaceHolderVar *phv)

Param * generate_new_exec_param(PlannerInfo *root, Oid paramtype, int32 paramtypmod, Oid paramcollation)

Param * replace_outer_agg(PlannerInfo *root, Aggref *agg)

List * identify_current_nestloop_params(PlannerInfo *root, Relids leftrelids)

Param * replace_outer_returning(PlannerInfo *root, ReturningExpr *rexpr)

Param * replace_outer_grouping(PlannerInfo *root, GroupingFunc *grp)

Param * replace_outer_var(PlannerInfo *root, Var *var)

void process_subquery_nestloop_params(PlannerInfo *root, List *subplan_params)

Param * replace_outer_placeholdervar(PlannerInfo *root, PlaceHolderVar *phv)

Param * replace_nestloop_param_placeholdervar(PlannerInfo *root, PlaceHolderVar *phv)

int assign_special_exec_param(PlannerInfo *root)

Param * replace_nestloop_param_var(PlannerInfo *root, Var *var)

#define lfirst_node(type, lc)

static int list_length(const List *l)

#define foreach_delete_current(lst, var_or_cell)

PlaceHolderInfo * find_placeholder_info(PlannerInfo *root, PlaceHolderVar *phv)

void IncrementVarSublevelsUp(Node *node, int delta_sublevels_up, int min_sublevels_up)

VarReturningType varreturningtype