PostgreSQL Source Code: src/backend/catalog/heap.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

22

23

24

25

26

27

28

29

31

74#include "utils/fmgroids.h"

78

79

80

85

88 Oid new_rel_oid,

89 Oid new_type_oid,

90 Oid reloftype,

91 Oid relowner,

92 char relkind,

96 Datum reloptions);

98 Oid typeNamespace,

99 Oid new_rel_oid,

100 char new_rel_kind,

101 Oid ownerid,

102 Oid new_row_type,

103 Oid new_array_type);

106 bool is_enforced, bool is_validated, bool is_local,

107 int16 inhcount, bool is_no_inherit, bool is_internal);

109 bool is_internal);

111 bool allow_merge, bool is_local,

112 bool is_enforced,

113 bool is_initially_valid,

114 bool is_no_inherit);

117 Node *raw_constraint,

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

145 .attname = {"ctid"},

146 .atttypid = TIDOID,

149 .atttypmod = -1,

154 .attislocal = true,

155};

156

158 .attname = {"xmin"},

159 .atttypid = XIDOID,

162 .atttypmod = -1,

167 .attislocal = true,

168};

169

171 .attname = {"cmin"},

172 .atttypid = CIDOID,

175 .atttypmod = -1,

180 .attislocal = true,

181};

182

184 .attname = {"xmax"},

185 .atttypid = XIDOID,

188 .atttypmod = -1,

193 .attislocal = true,

194};

195

197 .attname = {"cmax"},

198 .atttypid = CIDOID,

201 .atttypmod = -1,

206 .attislocal = true,

207};

208

209

210

211

212

213

214

216 .attname = {"tableoid"},

217 .atttypid = OIDOID,

218 .attlen = sizeof(Oid),

220 .atttypmod = -1,

225 .attislocal = true,

226};

227

229

230

231

232

233

234

237{

239 elog(ERROR, "invalid system attribute number %d", attno);

240 return SysAtt[-attno - 1];

241}

242

243

244

245

246

249{

250 int j;

251

253 {

255

257 return att;

258 }

259

260 return NULL;

261}

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

286 Oid relnamespace,

287 Oid reltablespace,

288 Oid relid,

290 Oid accessmtd,

292 char relkind,

293 char relpersistence,

294 bool shared_relation,

295 bool mapped_relation,

296 bool allow_system_table_mods,

299 bool create_storage)

300{

302

303

305

306

307

308

309

310

311

312

313

314

315 if (!allow_system_table_mods &&

320 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),

321 errmsg("permission denied to create \"%s.%s\"",

323 errdetail("System catalog modifications are currently disallowed.")));

324

327

328

329

330

331

332 if (!RELKIND_HAS_TABLESPACE(relkind))

334

335

336 if (!RELKIND_HAS_STORAGE(relkind))

337 create_storage = false;

338 else

339 {

340

341

342

343

345 relfilenumber = relid;

346 }

347

348

349

350

351

352

353

354

355

356

359

360

361

362

364 relnamespace,

365 tupDesc,

366 relid,

367 accessmtd,

368 relfilenumber,

369 reltablespace,

370 shared_relation,

371 mapped_relation,

372 relpersistence,

373 relkind);

374

375

376

377

378

379

380

381

382 if (create_storage)

383 {

384 if (RELKIND_HAS_TABLE_AM(rel->rd_rel->relkind))

386 relpersistence,

387 relfrozenxid, relminmxid);

388 else if (RELKIND_HAS_STORAGE(rel->rd_rel->relkind))

390 else

392 }

393

394

395

396

397

398

399 if (!create_storage && reltablespace != InvalidOid)

401 reltablespace);

402

403

405

406 return rel;

407}

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451void

453 int flags)

454{

455 int i;

456 int j;

457 int natts = tupdesc->natts;

458

459

462 (errcode(ERRCODE_TOO_MANY_COLUMNS),

463 errmsg("tables can have at most %d columns",

465

466

467

468

469

470

471

472 if (relkind != RELKIND_VIEW && relkind != RELKIND_COMPOSITE_TYPE)

473 {

474 for (i = 0; i < natts; i++)

475 {

477

480 (errcode(ERRCODE_DUPLICATE_COLUMN),

481 errmsg("column name \"%s\" conflicts with a system column name",

482 NameStr(attr->attname))));

483 }

484 }

485

486

487

488

489 for (i = 1; i < natts; i++)

490 {

491 for (j = 0; j < i; j++)

492 {

496 (errcode(ERRCODE_DUPLICATE_COLUMN),

497 errmsg("column name \"%s\" specified more than once",

499 }

500 }

501

502

503

504

505 for (i = 0; i < natts; i++)

506 {

510 NIL,

512 }

513}

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543void

545 Oid atttypid, Oid attcollation,

546 List *containing_rowtypes,

547 int flags)

548{

549 char att_typtype = get_typtype(atttypid);

550 Oid att_typelem;

551

552

554

555 if (att_typtype == TYPTYPE_PSEUDO)

556 {

557

558

559

560

561

562

563

564

565

566

567 if (!((atttypid == ANYARRAYOID && (flags & CHKATYPE_ANYARRAY)) ||

570 {

573 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),

574

575 errmsg("partition key column %s has pseudo-type %s",

577 else

579 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),

580 errmsg("column \"%s\" has pseudo-type %s",

582 }

583 }

584 else if (att_typtype == TYPTYPE_DOMAIN)

585 {

586

587

588

589

590

591

594 errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

595 errmsg("virtual generated column \"%s\" cannot have a domain type", attname));

596

597

598

599

601 containing_rowtypes,

602 flags);

603 }

604 else if (att_typtype == TYPTYPE_COMPOSITE)

605 {

606

607

608

611 int i;

612

613

614

615

616

617

618

621 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),

622 errmsg("composite type %s cannot be made a member of itself",

624

625 containing_rowtypes = lappend_oid(containing_rowtypes, atttypid);

626

628

630

631 for (i = 0; i < tupdesc->natts; i++)

632 {

634

635 if (attr->attisdropped)

636 continue;

638 attr->atttypid, attr->attcollation,

639 containing_rowtypes,

641 }

642

644

646 }

647 else if (att_typtype == TYPTYPE_RANGE)

648 {

649

650

651

654 containing_rowtypes,

655 flags);

656 }

658 {

659

660

661

663 containing_rowtypes,

664 flags);

665 }

666

667

668

669

670

672 {

675 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),

676

677 errmsg("no collation was derived for partition key column %s with collatable type %s",

679 errhint("Use the COLLATE clause to set the collation explicitly.")));

680 else

682 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),

683 errmsg("no collation was derived for column \"%s\" with collatable type %s",

685 errhint("Use the COLLATE clause to set the collation explicitly.")));

686 }

687}

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707void

710 Oid new_rel_oid,

713{

716 int nslots;

717 int natts = 0;

718 int slotCount = 0;

719 bool close_index = false;

720

722

723

727 for (int i = 0; i < nslots; i++)

729

730 while (natts < tupdesc->natts)

731 {

734

736

737 memset(slot[slotCount]->tts_isnull, false,

738 slot[slotCount]->tts_tupleDescriptor->natts * sizeof(bool));

739

742 else

744

745 slot[slotCount]->tts_values[Anum_pg_attribute_attname - 1] = NameGetDatum(&attrs->attname);

747 slot[slotCount]->tts_values[Anum_pg_attribute_attlen - 1] = Int16GetDatum(attrs->attlen);

748 slot[slotCount]->tts_values[Anum_pg_attribute_attnum - 1] = Int16GetDatum(attrs->attnum);

749 slot[slotCount]->tts_values[Anum_pg_attribute_atttypmod - 1] = Int32GetDatum(attrs->atttypmod);

750 slot[slotCount]->tts_values[Anum_pg_attribute_attndims - 1] = Int16GetDatum(attrs->attndims);

751 slot[slotCount]->tts_values[Anum_pg_attribute_attbyval - 1] = BoolGetDatum(attrs->attbyval);

752 slot[slotCount]->tts_values[Anum_pg_attribute_attalign - 1] = CharGetDatum(attrs->attalign);

753 slot[slotCount]->tts_values[Anum_pg_attribute_attstorage - 1] = CharGetDatum(attrs->attstorage);

754 slot[slotCount]->tts_values[Anum_pg_attribute_attcompression - 1] = CharGetDatum(attrs->attcompression);

755 slot[slotCount]->tts_values[Anum_pg_attribute_attnotnull - 1] = BoolGetDatum(attrs->attnotnull);

756 slot[slotCount]->tts_values[Anum_pg_attribute_atthasdef - 1] = BoolGetDatum(attrs->atthasdef);

757 slot[slotCount]->tts_values[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(attrs->atthasmissing);

758 slot[slotCount]->tts_values[Anum_pg_attribute_attidentity - 1] = CharGetDatum(attrs->attidentity);

759 slot[slotCount]->tts_values[Anum_pg_attribute_attgenerated - 1] = CharGetDatum(attrs->attgenerated);

760 slot[slotCount]->tts_values[Anum_pg_attribute_attisdropped - 1] = BoolGetDatum(attrs->attisdropped);

761 slot[slotCount]->tts_values[Anum_pg_attribute_attislocal - 1] = BoolGetDatum(attrs->attislocal);

762 slot[slotCount]->tts_values[Anum_pg_attribute_attinhcount - 1] = Int16GetDatum(attrs->attinhcount);

763 slot[slotCount]->tts_values[Anum_pg_attribute_attcollation - 1] = ObjectIdGetDatum(attrs->attcollation);

764 if (attrs_extra)

765 {

768

771 }

772 else

773 {

774 slot[slotCount]->tts_isnull[Anum_pg_attribute_attstattarget - 1] = true;

775 slot[slotCount]->tts_isnull[Anum_pg_attribute_attoptions - 1] = true;

776 }

777

778

779

780

781 slot[slotCount]->tts_isnull[Anum_pg_attribute_attacl - 1] = true;

782 slot[slotCount]->tts_isnull[Anum_pg_attribute_attfdwoptions - 1] = true;

783 slot[slotCount]->tts_isnull[Anum_pg_attribute_attmissingval - 1] = true;

784

786 slotCount++;

787

788

789

790

791

792 if (slotCount == nslots || natts == tupdesc->natts - 1)

793 {

794

795 if (!indstate)

796 {

798 close_index = true;

799 }

800

801

803 indstate);

804 slotCount = 0;

805 }

806

807 natts++;

808 }

809

810 if (close_index)

812 for (int i = 0; i < nslots; i++)

815}

816

817

818

819

820

821

822

823

824static void

827 char relkind)

828{

831 int natts = tupdesc->natts;

833 referenced;

834

835

836

837

839

841

843

844

845 for (int i = 0; i < natts; i++)

846 {

848

849

851 ObjectAddressSet(referenced, TypeRelationId, attr->atttypid);

853

854

855 if (OidIsValid(attr->attcollation) &&

856 attr->attcollation != DEFAULT_COLLATION_OID)

857 {

859 attr->attcollation);

861 }

862 }

863

864

865

866

867

868

869 if (relkind != RELKIND_VIEW && relkind != RELKIND_COMPOSITE_TYPE)

870 {

872

874

877 }

878

879

880

881

883

885}

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900void

903 Oid new_rel_oid,

905 Datum reloptions)

906{

909 bool nulls[Natts_pg_class];

911

912

914 memset(nulls, false, sizeof(nulls));

915

927 values[Anum_pg_class_relallvisible - 1] = Int32GetDatum(rd_rel->relallvisible);

928 values[Anum_pg_class_relallfrozen - 1] = Int32GetDatum(rd_rel->relallfrozen);

930 values[Anum_pg_class_relhasindex - 1] = BoolGetDatum(rd_rel->relhasindex);

931 values[Anum_pg_class_relisshared - 1] = BoolGetDatum(rd_rel->relisshared);

932 values[Anum_pg_class_relpersistence - 1] = CharGetDatum(rd_rel->relpersistence);

936 values[Anum_pg_class_relhasrules - 1] = BoolGetDatum(rd_rel->relhasrules);

937 values[Anum_pg_class_relhastriggers - 1] = BoolGetDatum(rd_rel->relhastriggers);

938 values[Anum_pg_class_relrowsecurity - 1] = BoolGetDatum(rd_rel->relrowsecurity);

939 values[Anum_pg_class_relforcerowsecurity - 1] = BoolGetDatum(rd_rel->relforcerowsecurity);

940 values[Anum_pg_class_relhassubclass - 1] = BoolGetDatum(rd_rel->relhassubclass);

941 values[Anum_pg_class_relispopulated - 1] = BoolGetDatum(rd_rel->relispopulated);

942 values[Anum_pg_class_relreplident - 1] = CharGetDatum(rd_rel->relreplident);

943 values[Anum_pg_class_relispartition - 1] = BoolGetDatum(rd_rel->relispartition);

947 if (relacl != (Datum) 0)

948 values[Anum_pg_class_relacl - 1] = relacl;

949 else

950 nulls[Anum_pg_class_relacl - 1] = true;

951 if (reloptions != (Datum) 0)

952 values[Anum_pg_class_reloptions - 1] = reloptions;

953 else

954 nulls[Anum_pg_class_reloptions - 1] = true;

955

956

957 nulls[Anum_pg_class_relpartbound - 1] = true;

958

960

961

963

965}

966

967

968

969

970

971

972

973

974static void

977 Oid new_rel_oid,

978 Oid new_type_oid,

979 Oid reloftype,

980 Oid relowner,

981 char relkind,

985 Datum reloptions)

986{

988

989

990

991

992

993 new_rel_reltup = new_rel_desc->rd_rel;

994

995

996 new_rel_reltup->relpages = 0;

997 new_rel_reltup->reltuples = -1;

998 new_rel_reltup->relallvisible = 0;

999 new_rel_reltup->relallfrozen = 0;

1000

1001

1002 if (relkind == RELKIND_SEQUENCE)

1003 {

1004 new_rel_reltup->relpages = 1;

1005 new_rel_reltup->reltuples = 1;

1006 }

1007

1008 new_rel_reltup->relfrozenxid = relfrozenxid;

1009 new_rel_reltup->relminmxid = relminmxid;

1010 new_rel_reltup->relowner = relowner;

1011 new_rel_reltup->reltype = new_type_oid;

1012 new_rel_reltup->reloftype = reloftype;

1013

1014

1015 new_rel_reltup->relispartition = false;

1016

1017

1018 new_rel_desc->rd_att->tdtypeid = new_type_oid ? new_type_oid : RECORDOID;

1020

1021

1023 relacl, reloptions);

1024}

1025

1026

1027

1028

1029

1030

1031

1032

1035 Oid typeNamespace,

1036 Oid new_rel_oid,

1037 char new_rel_kind,

1038 Oid ownerid,

1039 Oid new_row_type,

1040 Oid new_array_type)

1041{

1042 return

1043 TypeCreate(new_row_type,

1044 typeName,

1045 typeNamespace,

1046 new_rel_oid,

1047 new_rel_kind,

1048 ownerid,

1049 -1,

1050 TYPTYPE_COMPOSITE,

1051 TYPCATEGORY_COMPOSITE,

1052 false,

1054 F_RECORD_IN,

1055 F_RECORD_OUT,

1056 F_RECORD_RECV,

1057 F_RECORD_SEND,

1058 InvalidOid,

1059 InvalidOid,

1060 InvalidOid,

1061 InvalidOid,

1062 InvalidOid,

1063 false,

1064 new_array_type,

1065 InvalidOid,

1066 NULL,

1067 NULL,

1068 false,

1069 TYPALIGN_DOUBLE,

1070 TYPSTORAGE_EXTENDED,

1071 -1,

1072 0,

1073 false,

1074 InvalidOid);

1075}

1076

1077

1078

1079

1080

1081

1082

1083

1084

1085

1086

1087

1088

1089

1090

1091

1092

1093

1094

1095

1096

1097

1098

1099

1100

1101

1102

1103

1104

1105

1106

1107

1108

1109

1110

1113 Oid relnamespace,

1114 Oid reltablespace,

1115 Oid relid,

1116 Oid reltypeid,

1117 Oid reloftypeid,

1118 Oid ownerid,

1119 Oid accessmtd,

1121 List *cooked_constraints,

1122 char relkind,

1123 char relpersistence,

1124 bool shared_relation,

1125 bool mapped_relation,

1127 Datum reloptions,

1128 bool use_user_acl,

1129 bool allow_system_table_mods,

1130 bool is_internal,

1131 Oid relrewrite,

1133{

1136 Acl *relacl;

1137 Oid existing_relid;

1138 Oid old_type_oid;

1139 Oid new_type_oid;

1140

1141

1145

1147

1148

1149

1150

1152

1153

1154

1155

1156

1157

1160

1161

1162

1163

1164

1168 (errcode(ERRCODE_DUPLICATE_TABLE),

1169 errmsg("relation \"%s\" already exists", relname)));

1170

1171

1172

1173

1174

1175

1176

1177 old_type_oid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid,

1181 {

1186 errhint("A relation has an associated type of the same name, "

1187 "so you must use a name that doesn't conflict "

1188 "with any existing type.")));

1189 }

1190

1191

1192

1193

1194 if (shared_relation && reltablespace != GLOBALTABLESPACE_OID)

1195 elog(ERROR, "shared relations must be placed in pg_global tablespace");

1196

1197

1198

1199

1200

1201

1202

1204 {

1205

1207 {

1208

1209

1210

1211

1212 Assert(relkind != RELKIND_INDEX);

1213 Assert(relkind != RELKIND_PARTITIONED_INDEX);

1214

1215 if (relkind == RELKIND_TOASTVALUE)

1216 {

1217

1219 {

1222

1225 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

1226 errmsg("toast relfilenumber value not set when in binary upgrade mode")));

1227

1230 }

1231 }

1232 else

1233 {

1236 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

1237 errmsg("pg_class heap OID value not set when in binary upgrade mode")));

1238

1241

1242 if (RELKIND_HAS_STORAGE(relkind))

1243 {

1246 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

1247 errmsg("relfilenumber value not set when in binary upgrade mode")));

1248

1251 }

1252 }

1253 }

1254

1257 relpersistence);

1258 }

1259

1260

1261

1262

1263

1264

1266

1267

1268

1269

1270 if (use_user_acl)

1271 {

1272 switch (relkind)

1273 {

1274 case RELKIND_RELATION:

1275 case RELKIND_VIEW:

1276 case RELKIND_MATVIEW:

1277 case RELKIND_FOREIGN_TABLE:

1278 case RELKIND_PARTITIONED_TABLE:

1280 relnamespace);

1281 break;

1282 case RELKIND_SEQUENCE:

1284 relnamespace);

1285 break;

1286 default:

1287 relacl = NULL;

1288 break;

1289 }

1290 }

1291 else

1292 relacl = NULL;

1293

1294

1295

1296

1297

1298

1299

1300

1301

1302

1304 relnamespace,

1305 reltablespace,

1306 relid,

1307 relfilenumber,

1308 accessmtd,

1309 tupdesc,

1310 relkind,

1311 relpersistence,

1312 shared_relation,

1313 mapped_relation,

1314 allow_system_table_mods,

1315 &relfrozenxid,

1316 &relminmxid,

1317 true);

1318

1320

1321 new_rel_desc->rd_rel->relrewrite = relrewrite;

1322

1323

1324

1325

1326

1327

1328 if (!(relkind == RELKIND_SEQUENCE ||

1329 relkind == RELKIND_TOASTVALUE ||

1330 relkind == RELKIND_INDEX ||

1331 relkind == RELKIND_PARTITIONED_INDEX))

1332 {

1333 Oid new_array_oid;

1335 char *relarrayname;

1336

1337

1338

1339

1340

1342

1343

1344

1345

1346

1347

1348

1349

1350

1351

1353 relnamespace,

1354 relid,

1355 relkind,

1356 ownerid,

1357 reltypeid,

1358 new_array_oid);

1359 new_type_oid = new_type_addr.objectId;

1360 if (typaddress)

1361 *typaddress = new_type_addr;

1362

1363

1365

1366 TypeCreate(new_array_oid,

1367 relarrayname,

1368 relnamespace,

1369 InvalidOid,

1370 0,

1371 ownerid,

1372 -1,

1373 TYPTYPE_BASE,

1374 TYPCATEGORY_ARRAY,

1375 false,

1377 F_ARRAY_IN,

1378 F_ARRAY_OUT,

1379 F_ARRAY_RECV,

1380 F_ARRAY_SEND,

1381 InvalidOid,

1382 InvalidOid,

1383 F_ARRAY_TYPANALYZE,

1384 F_ARRAY_SUBSCRIPT_HANDLER,

1385 new_type_oid,

1386 true,

1387 InvalidOid,

1388 InvalidOid,

1389 NULL,

1390 NULL,

1391 false,

1392 TYPALIGN_DOUBLE,

1393 TYPSTORAGE_EXTENDED,

1394 -1,

1395 0,

1396 false,

1397 InvalidOid);

1398

1399 pfree(relarrayname);

1400 }

1401 else

1402 {

1403

1405 Assert(typaddress == NULL);

1406

1408 }

1409

1410

1411

1412

1413

1414

1415

1416

1418 new_rel_desc,

1419 relid,

1420 new_type_oid,

1421 reloftypeid,

1422 ownerid,

1423 relkind,

1424 relfrozenxid,

1425 relminmxid,

1427 reloptions);

1428

1429

1430

1431

1433

1434

1435

1436

1437

1438

1439

1440

1441

1442

1443

1444

1445

1446

1447

1448

1449 if (relkind != RELKIND_COMPOSITE_TYPE &&

1450 relkind != RELKIND_TOASTVALUE &&

1452 {

1454 referenced;

1456

1458

1460

1462

1464

1466

1467 ObjectAddressSet(referenced, NamespaceRelationId, relnamespace);

1469

1470 if (reloftypeid)

1471 {

1474 }

1475

1476

1477

1478

1479

1480

1481

1482

1483

1484 if ((RELKIND_HAS_TABLE_AM(relkind) && relkind != RELKIND_TOASTVALUE) ||

1485 (relkind == RELKIND_PARTITIONED_TABLE && OidIsValid(accessmtd)))

1486 {

1487 ObjectAddressSet(referenced, AccessMethodRelationId, accessmtd);

1489 }

1490

1493 }

1494

1495

1497

1498

1499

1500

1501

1502

1503

1504

1505 StoreConstraints(new_rel_desc, cooked_constraints, is_internal);

1506

1507

1508

1509

1512

1513

1514

1515

1516

1517 table_close(new_rel_desc, NoLock);

1519

1520 return relid;

1521}

1522

1523

1524

1525

1526

1527

1528

1529

1530

1531

1532static void

1534{

1539

1541

1543 Anum_pg_inherits_inhrelid,

1546

1547 scan = systable_beginscan(catalogRelation, InheritsRelidSeqnoIndexId, true,

1548 NULL, 1, &key);

1549

1552

1555}

1556

1557

1558

1559

1560

1561

1562

1563

1564

1565void

1567{

1570

1571

1573

1576 elog(ERROR, "cache lookup failed for relation %u", relid);

1577

1578

1580

1582

1584}

1585

1586

1587

1588

1589

1590

1591

1592

1593

1594void

1596{

1601

1602

1604

1605

1607 Anum_pg_attribute_attrelid,

1610

1612 NULL, 1, key);

1613

1614

1617

1618

1621}

1622

1623

1624

1625

1626

1627

1628

1629

1630

1631void

1633{

1638

1639

1641

1642

1644 Anum_pg_attribute_attrelid,

1648 Anum_pg_attribute_attnum,

1651

1653 NULL, 2, key);

1654

1655

1658

1659

1662}

1663

1664

1665

1666

1667

1668

1669

1670

1671

1672void

1674{

1680 Datum valuesAtt[Natts_pg_attribute] = {0};

1681 bool nullsAtt[Natts_pg_attribute] = {0};

1682 bool replacesAtt[Natts_pg_attribute] = {0};

1683

1684

1685

1686

1687

1688

1689

1691

1693

1698 elog(ERROR, "cache lookup failed for attribute %d of relation %u",

1701

1702

1703 attStruct->attisdropped = true;

1704

1705

1706

1707

1708

1709

1710

1711

1712

1714

1715

1716 attStruct->attnotnull = false;

1717

1718

1719 attStruct->attgenerated = '\0';

1720

1721

1722

1723

1724 snprintf(newattname, sizeof(newattname),

1725 "........pg.dropped.%d........", attnum);

1726 namestrcpy(&(attStruct->attname), newattname);

1727

1728

1729 attStruct->atthasmissing = false;

1730 nullsAtt[Anum_pg_attribute_attmissingval - 1] = true;

1731 replacesAtt[Anum_pg_attribute_attmissingval - 1] = true;

1732

1733

1734

1735

1736

1737 nullsAtt[Anum_pg_attribute_attstattarget - 1] = true;

1738 replacesAtt[Anum_pg_attribute_attstattarget - 1] = true;

1739 nullsAtt[Anum_pg_attribute_attacl - 1] = true;

1740 replacesAtt[Anum_pg_attribute_attacl - 1] = true;

1741 nullsAtt[Anum_pg_attribute_attoptions - 1] = true;

1742 replacesAtt[Anum_pg_attribute_attoptions - 1] = true;

1743 nullsAtt[Anum_pg_attribute_attfdwoptions - 1] = true;

1744 replacesAtt[Anum_pg_attribute_attfdwoptions - 1] = true;

1745

1747 valuesAtt, nullsAtt, replacesAtt);

1748

1750

1751

1752

1753

1754

1755

1756

1758

1760

1762}

1763

1764

1765

1766

1767

1768

1769

1770

1771

1772

1773void

1775{

1780

1781

1782

1783

1784

1785

1786

1787

1788

1789

1790

1793 elog(ERROR, "cache lookup failed for relation %u", relid);

1795 {

1796

1797

1798

1799

1800

1803

1804

1805

1806

1807

1809 if (OidIsValid(defaultPartOid) && relid != defaultPartOid)

1811 }

1812

1814

1815

1816

1817

1819

1820

1821

1822

1823

1824

1826

1827

1828

1829

1830

1831

1832

1834

1835

1836

1837

1838 if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)

1839 {

1842

1844

1847 elog(ERROR, "cache lookup failed for foreign table %u", relid);

1848

1850

1853 }

1854

1855

1856

1857

1858 if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)

1860

1861

1862

1863

1864

1865 if (relid == defaultPartOid)

1867

1868

1869

1870

1871 if (RELKIND_HAS_STORAGE(rel->rd_rel->relkind))

1873

1874

1876

1877

1878

1879

1880

1881

1883

1884

1885

1886

1888

1889

1890

1891

1893

1894

1895

1896

1897

1898

1899

1900

1902

1903

1904

1905

1907

1908

1909

1910

1912

1913

1914

1915

1917

1918

1919

1920

1922

1924 {

1925

1926

1927

1928

1929

1930 if (OidIsValid(defaultPartOid) && relid != defaultPartOid)

1932

1933

1934

1935

1936

1938

1939 }

1940}

1941

1942

1943

1944

1945

1946

1947

1948

1949

1950

1951

1952

1953void

1955{

1960 Datum repl_val[Natts_pg_attribute];

1961 bool repl_null[Natts_pg_attribute];

1962 bool repl_repl[Natts_pg_attribute];

1965 newtuple;

1966

1967 memset(repl_val, 0, sizeof(repl_val));

1968 memset(repl_null, false, sizeof(repl_null));

1969 memset(repl_repl, false, sizeof(repl_repl));

1970

1971 repl_val[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(false);

1972 repl_null[Anum_pg_attribute_attmissingval - 1] = true;

1973

1974 repl_repl[Anum_pg_attribute_atthasmissing - 1] = true;

1975 repl_repl[Anum_pg_attribute_attmissingval - 1] = true;

1976

1977

1978

1980

1981

1983 {

1988 elog(ERROR, "cache lookup failed for attribute %d of relation %u",

1990

1992

1993

1994 if (attrtuple->atthasmissing)

1995 {

1997 repl_val, repl_null, repl_repl);

1998

2000

2002 }

2003

2005 }

2006

2007

2008

2009

2010

2012}

2013

2014

2015

2016

2017

2018

2019void

2021{

2022 Datum valuesAtt[Natts_pg_attribute] = {0};

2023 bool nullsAtt[Natts_pg_attribute] = {0};

2024 bool replacesAtt[Natts_pg_attribute] = {0};

2028 newtup;

2029

2030

2031 Assert(rel->rd_rel->relkind == RELKIND_RELATION);

2032

2033

2035

2040 elog(ERROR, "cache lookup failed for attribute %d of relation %u",

2043

2044

2046 1,

2047 attStruct->atttypid,

2048 attStruct->attlen,

2049 attStruct->attbyval,

2050 attStruct->attalign));

2051

2052

2053 valuesAtt[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(true);

2054 replacesAtt[Anum_pg_attribute_atthasmissing - 1] = true;

2055

2056 valuesAtt[Anum_pg_attribute_attmissingval - 1] = missingval;

2057 replacesAtt[Anum_pg_attribute_attmissingval - 1] = true;

2058

2060 valuesAtt, nullsAtt, replacesAtt);

2062

2063

2066}

2067

2068

2069

2070

2071

2072

2073

2074

2075void

2077{

2078 Datum valuesAtt[Natts_pg_attribute] = {0};

2079 bool nullsAtt[Natts_pg_attribute] = {0};

2080 bool replacesAtt[Natts_pg_attribute] = {0};

2081 Datum missingval;

2084 tablerel;

2086 newtup;

2087

2088

2090

2091

2092 if (tablerel->rd_rel->relkind != RELKIND_RELATION)

2093 {

2095 return;

2096 }

2097

2098

2102 elog(ERROR, "cache lookup failed for attribute %s of relation %u",

2105

2106

2111

2112

2113 valuesAtt[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(true);

2114 replacesAtt[Anum_pg_attribute_atthasmissing - 1] = true;

2115 valuesAtt[Anum_pg_attribute_attmissingval - 1] = missingval;

2116 replacesAtt[Anum_pg_attribute_attmissingval - 1] = true;

2117

2119 valuesAtt, nullsAtt, replacesAtt);

2121

2122

2126}

2127

2128

2129

2130

2131

2132

2133

2134

2135

2136static Oid

2138 bool is_enforced, bool is_validated, bool is_local,

2139 int16 inhcount, bool is_no_inherit, bool is_internal)

2140{

2141 char *ccbin;

2142 List *varList;

2143 int keycount;

2145 Oid constrOid;

2146

2147

2148

2149

2151

2152

2153

2154

2155

2156

2157

2158

2161

2162 if (keycount > 0)

2163 {

2165 int i = 0;

2166

2168 foreach(vl, varList)

2169 {

2171 int j;

2172

2173 for (j = 0; j < i; j++)

2175 break;

2176 if (j == i)

2178 }

2179 keycount = i;

2180 }

2181 else

2182 attNos = NULL;

2183

2184

2185

2186

2187

2188 if (is_no_inherit &&

2189 rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)

2191 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),

2192 errmsg("cannot add NO INHERIT constraint to partitioned table \"%s\"",

2194

2195

2196

2197

2198 constrOid =

2201 CONSTRAINT_CHECK,

2202 false,

2203 false,

2204 is_enforced,

2205 is_validated,

2206 InvalidOid,

2208 attNos,

2209 keycount,

2210 keycount,

2211 InvalidOid,

2212 InvalidOid,

2213 InvalidOid,

2214 NULL,

2215 NULL,

2216 NULL,

2217 NULL,

2218 0,

2219 ' ',

2220 ' ',

2221 NULL,

2222 0,

2223 ' ',

2224 NULL,

2225 expr,

2226 ccbin,

2227 is_local,

2228 inhcount,

2229 is_no_inherit,

2230 false,

2231 is_internal);

2232

2234

2235 return constrOid;

2236}

2237

2238

2239

2240

2241

2242

2243static Oid

2245 bool is_validated, bool is_local, int inhcount,

2246 bool is_no_inherit)

2247{

2248 Oid constrOid;

2249

2251

2252 constrOid =

2255 CONSTRAINT_NOTNULL,

2256 false,

2257 false,

2258 true,

2259 is_validated,

2263 1,

2264 1,

2265 InvalidOid,

2266 InvalidOid,

2267 InvalidOid,

2268 NULL,

2269 NULL,

2270 NULL,

2271 NULL,

2272 0,

2273 ' ',

2274 ' ',

2275 NULL,

2276 0,

2277 ' ',

2278 NULL,

2279 NULL,

2280 NULL,

2281 is_local,

2282 inhcount,

2283 is_no_inherit,

2284 false,

2285 false);

2286 return constrOid;

2287}

2288

2289

2290

2291

2292

2293

2294

2295

2296

2297

2298

2299static void

2301{

2302 int numchecks = 0;

2304

2305 if (cooked_constraints == NIL)

2306 return;

2307

2308

2309

2310

2311

2312

2314

2315 foreach(lc, cooked_constraints)

2316 {

2318

2320 {

2323 is_internal);

2324 break;

2331 numchecks++;

2332 break;

2333

2334 default:

2335 elog(ERROR, "unrecognized constraint type: %d",

2337 }

2338 }

2339

2340 if (numchecks > 0)

2342}

2343

2344

2345

2346

2347

2348

2349

2350

2351

2352

2353

2354

2355

2356

2357

2358

2359

2360

2361

2362

2363

2364

2365

2366

2367

2368

2369

2370

2371

2372

2373

2376 List *newColDefaults,

2377 List *newConstraints,

2378 bool allow_merge,

2379 bool is_local,

2380 bool is_internal,

2381 const char *queryString)

2382{

2383 List *cookedConstraints = NIL;

2386 int numoldchecks;

2389 int numchecks;

2390 List *checknames;

2391 List *nnnames;

2394

2395

2396

2397

2399 oldconstr = tupleDesc->constr;

2400 if (oldconstr)

2401 numoldchecks = oldconstr->num_check;

2402 else

2403 numoldchecks = 0;

2404

2405

2406

2407

2408

2412 rel,

2414 NULL,

2415 false,

2416 true);

2418

2419

2420

2421

2423 {

2425 Oid defOid;

2426

2427 expr = cookDefault(pstate, colDef->raw_default,

2428 atp->atttypid, atp->atttypmod,

2430 atp->attgenerated);

2431

2432

2433

2434

2435

2436

2437

2438

2439

2440

2441

2442

2443

2444 if (expr == NULL ||

2445 (!colDef->generated &&

2448 continue;

2449

2450 defOid = StoreAttrDefault(rel, colDef->attnum, expr, is_internal);

2451

2454 cooked->conoid = defOid;

2455 cooked->name = NULL;

2456 cooked->attnum = colDef->attnum;

2457 cooked->expr = expr;

2460 cooked->is_local = is_local;

2461 cooked->inhcount = is_local ? 0 : 1;

2463 cookedConstraints = lappend(cookedConstraints, cooked);

2464 }

2465

2466

2467

2468

2469 numchecks = numoldchecks;

2470 checknames = NIL;

2471 nnnames = NIL;

2473 {

2474 Oid constrOid;

2475

2477 {

2478 char *ccname;

2479

2480 if (cdef->raw_expr != NULL)

2481 {

2482 Assert(cdef->cooked_expr == NULL);

2483

2484

2485

2486

2487

2490 }

2491 else

2492 {

2493 Assert(cdef->cooked_expr != NULL);

2494

2495

2496

2497

2498

2500 }

2501

2502

2503

2504

2505 if (cdef->conname != NULL)

2506 {

2507 ccname = cdef->conname;

2508

2509

2511 {

2512 if (strcmp(chkname, ccname) == 0)

2515 errmsg("check constraint \"%s\" already exists",

2516 ccname)));

2517 }

2518

2519

2520 checknames = lappend(checknames, ccname);

2521

2522

2523

2524

2525

2526

2527

2529 allow_merge, is_local,

2530 cdef->is_enforced,

2531 cdef->initially_valid,

2532 cdef->is_no_inherit))

2533 continue;

2534 }

2535 else

2536 {

2537

2538

2539

2540

2541

2542

2543

2544

2545

2546

2547

2548

2549

2551 char *colname;

2552

2554

2555

2557

2561 true);

2562 else

2563 colname = NULL;

2564

2566 colname,

2567 "check",

2569 checknames);

2570

2571

2572 checknames = lappend(checknames, ccname);

2573 }

2574

2575

2576

2577

2578 constrOid =

2579 StoreRelCheck(rel, ccname, expr, cdef->is_enforced,

2580 cdef->initially_valid, is_local,

2581 is_local ? 0 : 1, cdef->is_no_inherit,

2582 is_internal);

2583

2584 numchecks++;

2585

2588 cooked->conoid = constrOid;

2589 cooked->name = ccname;

2591 cooked->expr = expr;

2592 cooked->is_enforced = cdef->is_enforced;

2594 cooked->is_local = is_local;

2595 cooked->inhcount = is_local ? 0 : 1;

2597 cookedConstraints = lappend(cookedConstraints, cooked);

2598 }

2600 {

2603 int16 inhcount = is_local ? 0 : 1;

2604 char *nnname;

2605

2606

2610 errcode(ERRCODE_UNDEFINED_COLUMN),

2611 errmsg("column \"%s\" of relation \"%s\" does not exist",

2615 errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

2616 errmsg("cannot add not-null constraint on system column \"%s\"",

2618

2619 Assert(cdef->initially_valid != cdef->skip_validation);

2620

2621

2622

2623

2624

2625

2626

2628 is_local, cdef->is_no_inherit,

2629 cdef->skip_validation))

2630 continue;

2631

2632

2633

2634

2635

2636 if (cdef->conname)

2637 {

2640 cdef->conname))

2643 errmsg("constraint \"%s\" for relation \"%s\" already exists",

2645 nnname = cdef->conname;

2646 }

2647 else

2650 "not_null",

2652 nnnames);

2653 nnnames = lappend(nnnames, nnname);

2654

2655 constrOid =

2657 cdef->initially_valid,

2658 is_local,

2659 inhcount,

2660 cdef->is_no_inherit);

2661

2664 nncooked->conoid = constrOid;

2665 nncooked->name = nnname;

2666 nncooked->attnum = colnum;

2667 nncooked->expr = NULL;

2670 nncooked->is_local = is_local;

2671 nncooked->inhcount = inhcount;

2673

2674 cookedConstraints = lappend(cookedConstraints, nncooked);

2675 }

2676 }

2677

2678

2679

2680

2681

2682

2683

2684

2686

2687 return cookedConstraints;

2688}

2689

2690

2691

2692

2693

2694

2695

2696

2697

2698

2699

2700static bool

2702 bool allow_merge, bool is_local,

2703 bool is_enforced,

2704 bool is_initially_valid,

2705 bool is_no_inherit)

2706{

2707 bool found;

2712

2713

2715

2716 found = false;

2717

2719 Anum_pg_constraint_conrelid,

2723 Anum_pg_constraint_contypid,

2727 Anum_pg_constraint_conname,

2730

2731 conscan = systable_beginscan(conDesc, ConstraintRelidTypidNameIndexId, true,

2732 NULL, 3, skey);

2733

2734

2736 {

2738

2739

2740 if (con->contype == CONSTRAINT_CHECK)

2741 {

2743 bool isnull;

2744

2746 Anum_pg_constraint_conbin,

2747 conDesc->rd_att, &isnull);

2748 if (isnull)

2749 elog(ERROR, "null conbin for rel %s",

2752 found = true;

2753 }

2754

2755

2756

2757

2758

2759

2760

2761

2762

2763 if (is_local && !con->conislocal && !rel->rd_rel->relispartition)

2764 allow_merge = true;

2765

2766 if (!found || !allow_merge)

2769 errmsg("constraint \"%s\" for relation \"%s\" already exists",

2771

2772

2773 if (con->connoinherit)

2775 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

2776 errmsg("constraint \"%s\" conflicts with non-inherited constraint on relation \"%s\"",

2778

2779

2780

2781

2782

2783

2784 if (con->coninhcount > 0 && is_no_inherit)

2786 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

2787 errmsg("constraint \"%s\" conflicts with inherited constraint on relation \"%s\"",

2789

2790

2791

2792

2793

2794 if (is_initially_valid && con->conenforced && !con->convalidated)

2796 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

2797 errmsg("constraint \"%s\" conflicts with NOT VALID constraint on relation \"%s\"",

2799

2800

2801

2802

2803

2804

2805 if ((!is_local && is_enforced && !con->conenforced) ||

2806 (is_local && !is_enforced && con->conenforced))

2808 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

2809 errmsg("constraint \"%s\" conflicts with NOT ENFORCED constraint on relation \"%s\"",

2811

2812

2814 (errmsg("merging constraint \"%s\" with inherited definition",

2815 ccname)));

2816

2819

2820

2821

2822

2823

2824

2825 if (rel->rd_rel->relispartition)

2826 {

2827 con->coninhcount = 1;

2828 con->conislocal = false;

2829 }

2830 else

2831 {

2832 if (is_local)

2833 con->conislocal = true;

2835 &con->coninhcount))

2837 errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),

2838 errmsg("too many inheritance parents"));

2839 }

2840

2841 if (is_no_inherit)

2842 {

2844 con->connoinherit = true;

2845 }

2846

2847

2848

2849

2850

2851

2852

2853 if (is_enforced && !con->conenforced)

2854 {

2856 con->conenforced = true;

2857 con->convalidated = true;

2858 }

2859

2861 }

2862

2865

2866 return found;

2867}

2868

2869

2870

2871

2872

2873

2874

2875

2876

2877

2878

2879

2880

2881

2882

2885 List *old_notnulls)

2886{

2887 List *givennames;

2888 List *nnnames;

2890

2891

2892

2893

2894

2895

2896

2897 nnnames = NIL;

2898 givennames = NIL;

2899

2900

2901

2902

2903

2904

2905

2906

2907

2908

2909

2910

2911

2912

2913

2914 for (int outerpos = 0; outerpos < list_length(constraints); outerpos++)

2915 {

2918 char *conname;

2919 int inhcount = 0;

2920

2922

2924

2929 errcode(ERRCODE_UNDEFINED_COLUMN),

2930 errmsg("column \"%s\" of relation \"%s\" does not exist",

2935 errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

2936 errmsg("cannot add not-null constraint on system column \"%s\"",

2938

2939

2940

2941

2942

2943

2944 for (int restpos = outerpos + 1; restpos < list_length(constraints);)

2945 {

2947

2951 {

2954 errcode(ERRCODE_SYNTAX_ERROR),

2955 errmsg("conflicting NO INHERIT declaration for not-null constraint on column \"%s\"",

2957

2958

2959

2960

2961

2963 {

2966 else if (strcmp(constr->conname, other->conname) != 0)

2968 errcode(ERRCODE_SYNTAX_ERROR),

2969 errmsg("conflicting not-null constraint names \"%s\" and \"%s\"",

2971 }

2972

2973

2975 }

2976 else

2977 restpos++;

2978 }

2979

2980

2981

2982

2983

2984

2985

2986

2987

2989 {

2990 if (old->attnum == attnum)

2991 {

2992

2993

2994

2995

2998 (errcode(ERRCODE_DATATYPE_MISMATCH),

2999 errmsg("cannot define not-null constraint on column \"%s\" with NO INHERIT",

3001 errdetail("The column has an inherited not-null constraint.")));

3002

3003 inhcount++;

3005 }

3006 }

3007

3008

3009

3010

3011

3012

3014 {

3016 {

3017 if (strcmp(thisname, constr->conname) == 0)

3020 errmsg("constraint \"%s\" for relation \"%s\" already exists",

3023 }

3024

3025 conname = constr->conname;

3026 givennames = lappend(givennames, conname);

3027 }

3028 else

3032 "not_null",

3034 nnnames);

3035 nnnames = lappend(nnnames, conname);

3036

3040

3042 }

3043

3044

3045

3046

3047

3048

3049

3050

3051

3052

3053

3054

3055

3056

3057

3058 for (int outerpos = 0; outerpos < list_length(old_notnulls); outerpos++)

3059 {

3061 char *conname = NULL;

3062 int inhcount = 1;

3063

3067

3068

3069

3070

3071 if (conname == NULL)

3072 conname = cooked->name;

3073

3074 for (int restpos = outerpos + 1; restpos < list_length(old_notnulls);)

3075 {

3077

3081 {

3082 if (conname == NULL)

3083 conname = other->name;

3084

3085 inhcount++;

3087 }

3088 else

3089 restpos++;

3090 }

3091

3092

3093 if (conname != NULL)

3094 {

3096 {

3097 if (strcmp(thisname, conname) == 0)

3098 {

3099 conname = NULL;

3100 break;

3101 }

3102 }

3103 }

3104

3105

3106 if (conname == NULL)

3109 cooked->attnum, false),

3110 "not_null",

3112 nnnames);

3113 nnnames = lappend(nnnames, conname);

3114

3115

3117 false, inhcount, false);

3118

3120 }

3121

3122 return nncols;

3123}

3124

3125

3126

3127

3128

3129

3130

3131

3132

3133

3134

3135static void

3137{

3141

3146 elog(ERROR, "cache lookup failed for relation %u",

3149

3150 if (relStruct->relchecks != numchecks)

3151 {

3152 relStruct->relchecks = numchecks;

3153

3155 }

3156 else

3157 {

3158

3160 }

3161

3164}

3165

3166

3167

3168

3169static bool

3171{

3173

3174 if (node == NULL)

3175 return false;

3176 else if (IsA(node, Var))

3177 {

3178 Var *var = (Var *) node;

3179 Oid relid;

3181

3184 return false;

3185

3187

3190 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

3191 errmsg("cannot use generated column \"%s\" in column generation expression",

3193 errdetail("A generated column cannot reference another generated column."),

3195

3198 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

3199 errmsg("cannot use whole-row variable in column generation expression"),

3200 errdetail("This would cause the generated column to depend on its own value."),

3202

3203

3204 return false;

3205 }

3206 else

3208 context);

3209}

3210

3211static void

3213{

3215}

3216

3217

3218

3219

3220

3221

3222

3223

3224

3225

3226

3227

3228

3231 Node *raw_default,

3232 Oid atttypid,

3233 int32 atttypmod,

3235 char attgenerated)

3236{

3238

3239 Assert(raw_default != NULL);

3240

3241

3242

3243

3245

3246 if (attgenerated)

3247 {

3248

3250

3251

3254 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

3255 errmsg("generation expression is not immutable")));

3256 }

3257 else

3258 {

3259

3260

3261

3262

3264 }

3265

3266

3267

3268

3269

3270

3272 {

3274

3276 atttypid, atttypmod,

3279 -1);

3280 if (expr == NULL)

3282 (errcode(ERRCODE_DATATYPE_MISMATCH),

3283 errmsg("column \"%s\" is of type %s"

3284 " but default expression is of type %s",

3288 errhint("You will need to rewrite or cast the expression.")));

3289 }

3290

3291

3292

3293

3295

3296 return expr;

3297}

3298

3299

3300

3301

3302

3303

3304

3305

3306static Node *

3308 Node *raw_constraint,

3310{

3312

3313

3314

3315

3317

3318

3319

3320

3322

3323

3324

3325

3327

3328

3329

3330

3331

3334 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),

3335 errmsg("only table \"%s\" can be referenced in check constraint",

3337

3338 return expr;

3339}

3340

3341

3342

3343

3344void

3346{

3352

3354

3355

3357 Anum_pg_statistic_starelid,

3360

3362 true, NULL, 1, key);

3363

3365 {

3367

3368

3371

3372

3373 statform->starelid = torelid;

3374

3375

3376 if (indstate == NULL)

3378

3380

3382 }

3383

3385

3386 if (indstate != NULL)

3389}

3390

3391

3392

3393

3394

3395

3396

3397void

3399{

3403 int nkeys;

3405

3407

3409 Anum_pg_statistic_starelid,

3412

3414 nkeys = 1;

3415 else

3416 {

3418 Anum_pg_statistic_staattnum,

3421 nkeys = 2;

3422 }

3423

3424 scan = systable_beginscan(pgstatistic, StatisticRelidAttnumInhIndexId, true,

3425 NULL, nkeys, key);

3426

3427

3430

3432

3434}

3435

3436

3437

3438

3439

3440

3441

3442

3443

3444static void

3446{

3448

3449

3451 {

3455

3456

3458

3459

3460

3461

3462

3463

3464

3465

3466

3468

3469

3470

3471

3473

3474

3475

3476 index_build(heapRelation, currentIndex, indexInfo, true, false);

3477

3478

3480 }

3481}

3482

3483

3484

3485

3486

3487

3488

3489

3490

3491

3492void

3494{

3497

3498

3499 foreach(cell, relids)

3500 {

3503

3505 relations = lappend(relations, rel);

3506 }

3507

3508

3510

3511

3512 foreach(cell, relations)

3513 {

3515

3516

3518

3519

3521 }

3522}

3523

3524

3525

3526

3527

3528

3529

3530

3531

3532

3533void

3535{

3536 Oid toastrelid;

3537

3538

3539

3540

3541

3542 if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)

3543 return;

3544

3545

3547

3548

3550

3551

3552 toastrelid = rel->rd_rel->reltoastrelid;

3554 {

3556

3559

3561 }

3562}

3563

3564

3565

3566

3567

3568

3569

3570

3571

3572

3573

3574

3575

3576

3577void

3579{

3581 List *dependents;

3583

3584

3585

3586

3587

3588

3589

3590

3591

3592 foreach(cell, relations)

3593 {

3595

3596 if (rel->rd_rel->relhastriggers ||

3597 rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)

3599 }

3600

3601

3602

3603

3604 if (oids == NIL)

3605 return;

3606

3607

3608

3609

3610

3612 if (dependents == NIL)

3613 return;

3614

3615

3616

3617

3618

3619

3620

3621

3622 foreach(cell, oids)

3623 {

3626

3628

3629 foreach(cell2, dependents)

3630 {

3632

3634 {

3637

3638 if (tempTables)

3640 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

3641 errmsg("unsupported ON COMMIT and foreign key combination"),

3642 errdetail("Table \"%s\" references \"%s\", but they do not have the same ON COMMIT setting.",

3644 else

3646 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

3647 errmsg("cannot truncate a table referenced in a foreign key constraint"),

3648 errdetail("Table \"%s\" references \"%s\".",

3650 errhint("Truncate table \"%s\" at the same time, "

3651 "or use TRUNCATE ... CASCADE.",

3652 relname2)));

3653 }

3654 }

3655 }

3656}

3657

3658

3659

3660

3661

3662

3663

3664

3665

3666

3667

3668

3669

3670

3671

3674{

3677 List *parent_cons;

3683 bool restart;

3684

3686

3687

3688

3689

3690

3692

3693restart:

3694 restart = false;

3695 parent_cons = NIL;

3696

3698 NULL, 0, NULL);

3699

3701 {

3703

3704

3705 if (con->contype != CONSTRAINT_FOREIGN)

3706 continue;

3707

3708

3710 continue;

3711

3712

3713

3714

3715

3716

3717

3720 parent_cons = lappend_oid(parent_cons, con->conparentid);

3721

3722

3723

3724

3725

3727 result = lappend_oid(result, con->conrelid);

3728 }

3729

3731

3732

3733

3734

3735

3736

3737

3738

3739 foreach(cell, parent_cons)

3740 {

3742

3744 Anum_pg_constraint_oid,

3747

3749 true, NULL, 1, &key);

3750

3753 {

3755

3756

3757

3758

3759

3760

3761

3762

3763

3764

3765

3766

3767

3770 con->conparentid);

3772 {

3773 oids = lappend_oid(oids, con->confrelid);

3774 restart = true;

3775 }

3776 }

3777

3779 }

3780

3782 if (restart)

3783 goto restart;

3784

3787

3788

3791

3792 return result;

3793}

3794

3795

3796

3797

3798

3799void

3801 char strategy,

3802 int16 partnatts,

3804 List *partexprs,

3805 Oid *partopclass,

3806 Oid *partcollation)

3807{

3808 int i;

3812 Datum partexprDatum;

3813 Relation pg_partitioned_table;

3815 Datum values[Natts_pg_partitioned_table];

3816 bool nulls[Natts_pg_partitioned_table] = {0};

3820

3821 Assert(rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);

3822

3823

3825 partopclass_vec = buildoidvector(partopclass, partnatts);

3826 partcollation_vec = buildoidvector(partcollation, partnatts);

3827

3828

3829 if (partexprs)

3830 {

3831 char *exprString;

3832

3835 pfree(exprString);

3836 }

3837 else

3838 partexprDatum = (Datum) 0;

3839

3841

3842

3843 if (!partexprDatum)

3844 nulls[Anum_pg_partitioned_table_partexprs - 1] = true;

3845

3847 values[Anum_pg_partitioned_table_partstrat - 1] = CharGetDatum(strategy);

3848 values[Anum_pg_partitioned_table_partnatts - 1] = Int16GetDatum(partnatts);

3850 values[Anum_pg_partitioned_table_partattrs - 1] = PointerGetDatum(partattrs_vec);

3851 values[Anum_pg_partitioned_table_partclass - 1] = PointerGetDatum(partopclass_vec);

3852 values[Anum_pg_partitioned_table_partcollation - 1] = PointerGetDatum(partcollation_vec);

3853 values[Anum_pg_partitioned_table_partexprs - 1] = partexprDatum;

3854

3856

3859

3860

3863

3864

3865 for (i = 0; i < partnatts; i++)

3866 {

3867 ObjectAddressSet(referenced, OperatorClassRelationId, partopclass[i]);

3869

3870

3872 partcollation[i] != DEFAULT_COLLATION_OID)

3873 {

3874 ObjectAddressSet(referenced, CollationRelationId, partcollation[i]);

3876 }

3877 }

3878

3881

3882

3883

3884

3885

3886

3887

3888 for (i = 0; i < partnatts; i++)

3889 {

3890 if (partattrs[i] == 0)

3891 continue;

3892

3896 }

3897

3898

3899

3900

3901

3902

3903

3904 if (partexprs)

3906 (Node *) partexprs,

3910 true );

3911

3912

3913

3914

3915

3916

3918}

3919

3920

3921

3922

3923

3924void

3926{

3929

3931

3934 elog(ERROR, "cache lookup failed for partition key of relation %u",

3935 relid);

3936

3938

3941}

3942

3943

3944

3945

3946

3947

3948

3949

3950

3951

3952

3953

3954

3955void

3957{

3960 newtuple;

3961 Datum new_val[Natts_pg_class];

3962 bool new_null[Natts_pg_class],

3963 new_repl[Natts_pg_class];

3964 Oid defaultPartOid;

3965

3966

3971 elog(ERROR, "cache lookup failed for relation %u",

3973

3974#ifdef USE_ASSERT_CHECKING

3975 {

3977 bool isnull;

3978

3980 Assert(!classForm->relispartition);

3981 (void) SysCacheGetAttr(RELOID, tuple, Anum_pg_class_relpartbound,

3982 &isnull);

3984 }

3985#endif

3986

3987

3988 memset(new_val, 0, sizeof(new_val));

3989 memset(new_null, false, sizeof(new_null));

3990 memset(new_repl, false, sizeof(new_repl));

3992 new_null[Anum_pg_class_relpartbound - 1] = false;

3993 new_repl[Anum_pg_class_relpartbound - 1] = true;

3995 new_val, new_null, new_repl);

3996

3998

3999

4000

4001

4002

4003 if (rel->rd_rel->relkind == RELKIND_RELATION && rel->rd_rel->relhassubclass)

4005

4009

4010

4011

4012

4013

4017

4018

4020

4021

4022

4023

4024

4025

4026

4027 defaultPartOid =

4031

4033}

void recordDependencyOnNewAcl(Oid classId, Oid objectId, int32 objsubId, Oid ownerId, Acl *acl)

Acl * get_user_default_acl(ObjectType objtype, Oid ownerId, Oid nsp_oid)

ArrayType * construct_array(Datum *elems, int nelems, Oid elmtype, int elmlen, bool elmbyval, char elmalign)

#define InvalidAttrNumber

static Datum values[MAXATTR]

#define CStringGetTextDatum(s)

#define TextDatumGetCString(d)

TransactionId MultiXactId

#define OidIsValid(objectId)

bool IsToastNamespace(Oid namespaceId)

RelFileNumber GetNewRelFileNumber(Oid reltablespace, Relation pg_class, char relpersistence)

bool IsCatalogNamespace(Oid namespaceId)

bool contain_mutable_functions_after_planning(Expr *expr)

void record_object_address_dependencies(const ObjectAddress *depender, ObjectAddresses *referenced, DependencyType behavior)

void recordDependencyOnSingleRelExpr(const ObjectAddress *depender, Node *expr, Oid relId, DependencyType behavior, DependencyType self_behavior, bool reverse_self)

void add_exact_object_address(const ObjectAddress *object, ObjectAddresses *addrs)

ObjectAddresses * new_object_addresses(void)

void free_object_addresses(ObjectAddresses *addrs)

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

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

int errcode(int sqlerrcode)

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

#define ereport(elevel,...)

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

TupleTableSlot * MakeSingleTupleTableSlot(TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)

void ExecDropSingleTupleTableSlot(TupleTableSlot *slot)

TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)

const TupleTableSlotOps TTSOpsHeapTuple

#define OidFunctionCall3(functionId, arg1, arg2, arg3)

char * format_type_be(Oid type_oid)

void systable_endscan(SysScanDesc sysscan)

HeapTuple systable_getnext(SysScanDesc sysscan)

SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)

Assert(PointerIsAligned(start, uint64))

void RemoveAttributeById(Oid relid, AttrNumber attnum)

void RelationClearMissing(Relation rel)

void SetAttrMissing(Oid relid, char *attname, char *value)

static Oid StoreRelCheck(Relation rel, const char *ccname, Node *expr, bool is_enforced, bool is_validated, bool is_local, int16 inhcount, bool is_no_inherit, bool is_internal)

List * heap_truncate_find_FKs(List *relationIds)

void DeleteSystemAttributeTuples(Oid relid)

void StorePartitionKey(Relation rel, char strategy, int16 partnatts, AttrNumber *partattrs, List *partexprs, Oid *partopclass, Oid *partcollation)

static void StoreConstraints(Relation rel, List *cooked_constraints, bool is_internal)

static void AddNewAttributeTuples(Oid new_rel_oid, TupleDesc tupdesc, char relkind)

void DeleteRelationTuple(Oid relid)

static void RelationTruncateIndexes(Relation heapRelation)

RelFileNumber binary_upgrade_next_heap_pg_class_relfilenumber

static void AddNewRelationTuple(Relation pg_class_desc, Relation new_rel_desc, Oid new_rel_oid, Oid new_type_oid, Oid reloftype, Oid relowner, char relkind, TransactionId relfrozenxid, TransactionId relminmxid, Datum relacl, Datum reloptions)

void DeleteAttributeTuples(Oid relid)

void RemoveStatistics(Oid relid, AttrNumber attnum)

static const FormData_pg_attribute a4

RelFileNumber binary_upgrade_next_toast_pg_class_relfilenumber

static ObjectAddress AddNewRelationType(const char *typeName, Oid typeNamespace, Oid new_rel_oid, char new_rel_kind, Oid ownerid, Oid new_row_type, Oid new_array_type)

static const FormData_pg_attribute a1

Oid heap_create_with_catalog(const char *relname, Oid relnamespace, Oid reltablespace, Oid relid, Oid reltypeid, Oid reloftypeid, Oid ownerid, Oid accessmtd, TupleDesc tupdesc, List *cooked_constraints, char relkind, char relpersistence, bool shared_relation, bool mapped_relation, OnCommitAction oncommit, Datum reloptions, bool use_user_acl, bool allow_system_table_mods, bool is_internal, Oid relrewrite, ObjectAddress *typaddress)

void heap_truncate(List *relids)

static bool MergeWithExistingConstraint(Relation rel, const char *ccname, Node *expr, bool allow_merge, bool is_local, bool is_enforced, bool is_initially_valid, bool is_no_inherit)

static const FormData_pg_attribute *const SysAtt[]

static Oid StoreRelNotNull(Relation rel, const char *nnname, AttrNumber attnum, bool is_validated, bool is_local, int inhcount, bool is_no_inherit)

void CheckAttributeType(const char *attname, Oid atttypid, Oid attcollation, List *containing_rowtypes, int flags)

const FormData_pg_attribute * SystemAttributeByName(const char *attname)

void CopyStatistics(Oid fromrelid, Oid torelid)

void heap_truncate_check_FKs(List *relations, bool tempTables)

static const FormData_pg_attribute a6

static bool check_nested_generated_walker(Node *node, void *context)

static void SetRelationNumChecks(Relation rel, int numchecks)

static const FormData_pg_attribute a3

static void RelationRemoveInheritance(Oid relid)

static const FormData_pg_attribute a2

void StorePartitionBound(Relation rel, Relation parent, PartitionBoundSpec *bound)

List * AddRelationNotNullConstraints(Relation rel, List *constraints, List *old_notnulls)

void heap_drop_with_catalog(Oid relid)

List * AddRelationNewConstraints(Relation rel, List *newColDefaults, List *newConstraints, bool allow_merge, bool is_local, bool is_internal, const char *queryString)

void InsertPgClassTuple(Relation pg_class_desc, Relation new_rel_desc, Oid new_rel_oid, Datum relacl, Datum reloptions)

void CheckAttributeNamesTypes(TupleDesc tupdesc, char relkind, int flags)

static void check_nested_generated(ParseState *pstate, Node *node)

Oid binary_upgrade_next_toast_pg_class_oid

void InsertPgAttributeTuples(Relation pg_attribute_rel, TupleDesc tupdesc, Oid new_rel_oid, const FormExtraData_pg_attribute tupdesc_extra[], CatalogIndexState indstate)

Node * cookDefault(ParseState *pstate, Node *raw_default, Oid atttypid, int32 atttypmod, const char *attname, char attgenerated)

void heap_truncate_one_rel(Relation rel)

void RemovePartitionKeyByRelId(Oid relid)

Oid binary_upgrade_next_heap_pg_class_oid

const FormData_pg_attribute * SystemAttributeDefinition(AttrNumber attno)

static const FormData_pg_attribute a5

void StoreAttrMissingVal(Relation rel, AttrNumber attnum, Datum missingval)

Relation heap_create(const char *relname, Oid relnamespace, Oid reltablespace, Oid relid, RelFileNumber relfilenumber, Oid accessmtd, TupleDesc tupDesc, char relkind, char relpersistence, bool shared_relation, bool mapped_relation, bool allow_system_table_mods, TransactionId *relfrozenxid, MultiXactId *relminmxid, bool create_storage)

static Node * cookConstraint(ParseState *pstate, Node *raw_constraint, char *relname)

#define CHKATYPE_ANYRECORD

#define CHKATYPE_ANYARRAY

#define CHKATYPE_IS_VIRTUAL

#define CHKATYPE_IS_PARTKEY

HeapTuple heap_modify_tuple(HeapTuple tuple, TupleDesc tupleDesc, const Datum *replValues, const bool *replIsnull, const bool *doReplace)

HeapTuple heap_copytuple(HeapTuple tuple)

HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)

void heap_freetuple(HeapTuple htup)

#define HeapTupleIsValid(tuple)

static void * GETSTRUCT(const HeapTupleData *tuple)

#define MaxHeapAttributeNumber

static Datum fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)

IndexInfo * BuildDummyIndexInfo(Relation index)

void index_build(Relation heapRelation, Relation indexRelation, IndexInfo *indexInfo, bool isreindex, bool parallel)

void index_close(Relation relation, LOCKMODE lockmode)

Relation index_open(Oid relationId, LOCKMODE lockmode)

void CatalogTupleUpdate(Relation heapRel, ItemPointer otid, HeapTuple tup)

void CatalogTuplesMultiInsertWithInfo(Relation heapRel, TupleTableSlot **slot, int ntuples, CatalogIndexState indstate)

void CatalogTupleInsertWithInfo(Relation heapRel, HeapTuple tup, CatalogIndexState indstate)

void CatalogCloseIndexes(CatalogIndexState indstate)

void CatalogTupleInsert(Relation heapRel, HeapTuple tup)

CatalogIndexState CatalogOpenIndexes(Relation heapRel)

void CatalogTupleDelete(Relation heapRel, ItemPointer tid)

#define MAX_CATALOG_MULTI_INSERT_BYTES

int2vector * buildint2vector(const int16 *int2s, int n)

static bool pg_add_s16_overflow(int16 a, int16 b, int16 *result)

void CacheInvalidateRelcache(Relation relation)

void CacheInvalidateRelcacheByRelid(Oid relid)

struct ItemPointerData ItemPointerData

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

void list_sort(List *list, list_sort_comparator cmp)

List * list_delete_nth_cell(List *list, int n)

List * list_copy(const List *oldlist)

List * lappend_int(List *list, int datum)

List * lappend_oid(List *list, Oid datum)

List * list_append_unique_oid(List *list, Oid datum)

void list_deduplicate_oid(List *list)

int list_oid_cmp(const ListCell *p1, const ListCell *p2)

List * list_delete_last(List *list)

void list_free(List *list)

bool list_member_oid(const List *list, Oid datum)

List * list_union(const List *list1, const List *list2)

void LockRelationOid(Oid relid, LOCKMODE lockmode)

#define AccessExclusiveLock

Oid get_range_subtype(Oid rangeOid)

char * get_rel_name(Oid relid)

AttrNumber get_attnum(Oid relid, const char *attname)

Oid get_element_type(Oid typid)

char get_attgenerated(Oid relid, AttrNumber attnum)

char * get_attname(Oid relid, AttrNumber attnum, bool missing_ok)

Oid get_range_collation(Oid rangeOid)

bool type_is_collatable(Oid typid)

Oid get_typ_typrelid(Oid typid)

char get_typtype(Oid typid)

Oid getBaseType(Oid typid)

char * get_namespace_name(Oid nspid)

Oid get_relname_relid(const char *relname, Oid relnamespace)

char * pstrdup(const char *in)

void pfree(void *pointer)

#define IsBootstrapProcessingMode()

#define IsNormalProcessingMode()

#define InvalidMultiXactId

void namestrcpy(Name name, const char *str)

Oid exprType(const Node *expr)

#define expression_tree_walker(n, w, c)

#define IsA(nodeptr, _type_)

#define castNode(_type_, nodeptr)

#define InvokeObjectPostCreateHookArg(classId, objectId, subId, is_internal)

#define ObjectAddressSet(addr, class_id, object_id)

#define ObjectAddressSubSet(addr, class_id, object_id, object_sub_id)

oidvector * buildoidvector(const Oid *oids, int n)

char * nodeToString(const void *obj)

Node * coerce_to_boolean(ParseState *pstate, Node *node, const char *constructName)

Node * coerce_to_target_type(ParseState *pstate, Node *expr, Oid exprtype, Oid targettype, int32 targettypmod, CoercionContext ccontext, CoercionForm cformat, int location)

void assign_expr_collations(ParseState *pstate, Node *expr)

Node * transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)

int parser_errposition(ParseState *pstate, int location)

ParseState * make_parsestate(ParseState *parentParseState)

@ EXPR_KIND_COLUMN_DEFAULT

@ EXPR_KIND_GENERATED_COLUMN

@ EXPR_KIND_CHECK_CONSTRAINT

ParseNamespaceItem * addRangeTableEntryForRelation(ParseState *pstate, Relation rel, int lockmode, Alias *alias, bool inh, bool inFromCl)

void addNSItemToQuery(ParseState *pstate, ParseNamespaceItem *nsitem, bool addToJoinList, bool addToRelNameSpace, bool addToVarNameSpace)

#define rt_fetch(rangetable_index, rangetable)

PartitionDesc RelationGetPartitionDesc(Relation rel, bool omit_detached)

Oid get_default_oid_from_partdesc(PartitionDesc partdesc)

void update_default_partition_oid(Oid parentId, Oid defaultPartId)

Oid get_default_partition_oid(Oid parentId)

Oid get_partition_parent(Oid relid, bool even_if_detached)

Oid StoreAttrDefault(Relation rel, AttrNumber attnum, Node *expr, bool is_internal)

FormData_pg_attribute * Form_pg_attribute

FormData_pg_class * Form_pg_class

Oid CreateConstraintEntry(const char *constraintName, Oid constraintNamespace, char constraintType, bool isDeferrable, bool isDeferred, bool isEnforced, bool isValidated, Oid parentConstrId, Oid relId, const int16 *constraintKey, int constraintNKeys, int constraintNTotalKeys, Oid domainId, Oid indexRelId, Oid foreignRelId, const int16 *foreignKey, const Oid *pfEqOp, const Oid *ppEqOp, const Oid *ffEqOp, int foreignNKeys, char foreignUpdateType, char foreignDeleteType, const int16 *fkDeleteSetCols, int numFkDeleteSetCols, char foreignMatchType, const Oid *exclOp, Node *conExpr, const char *conBin, bool conIsLocal, int16 conInhCount, bool conNoInherit, bool conPeriod, bool is_internal)

bool ConstraintNameIsUsed(ConstraintCategory conCat, Oid objId, const char *conname)

char * ChooseConstraintName(const char *name1, const char *name2, const char *label, Oid namespaceid, List *others)

bool AdjustNotNullInheritance(Oid relid, AttrNumber attnum, bool is_local, bool is_no_inherit, bool is_notvalid)

FormData_pg_constraint * Form_pg_constraint

void recordDependencyOn(const ObjectAddress *depender, const ObjectAddress *referenced, DependencyType behavior)

void recordDependencyOnCurrentExtension(const ObjectAddress *object, bool isReplace)

static int list_length(const List *l)

#define foreach_delete_current(lst, var_or_cell)

#define list_make1_oid(x1)

#define foreach_ptr(type, var, lst)

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

#define foreach_node(type, var, lst)

#define list_nth_node(type, list, n)

void recordDependencyOnOwner(Oid classId, Oid objectId, Oid owner)

void recordDependencyOnTablespace(Oid classId, Oid objectId, Oid tablespace)

FormData_pg_statistic * Form_pg_statistic

void RemoveSubscriptionRel(Oid subid, Oid relid)

ObjectAddress TypeCreate(Oid newTypeOid, const char *typeName, Oid typeNamespace, Oid relationOid, char relationKind, Oid ownerId, int16 internalSize, char typeType, char typeCategory, bool typePreferred, char typDelim, Oid inputProcedure, Oid outputProcedure, Oid receiveProcedure, Oid sendProcedure, Oid typmodinProcedure, Oid typmodoutProcedure, Oid analyzeProcedure, Oid subscriptProcedure, Oid elementType, bool isImplicitArray, Oid arrayType, Oid baseType, const char *defaultTypeValue, char *defaultTypeBin, bool passedByValue, char alignment, char storage, int32 typeMod, int32 typNDims, bool typeNotNull, Oid typeCollation)

bool moveArrayTypeName(Oid typeOid, const char *typeName, Oid typeNamespace)

char * makeArrayTypeName(const char *typeName, Oid typeNamespace)

void pgstat_create_relation(Relation rel)

void pgstat_drop_relation(Relation rel)

static Datum PointerGetDatum(const void *X)

static Datum Float4GetDatum(float4 X)

static Datum TransactionIdGetDatum(TransactionId X)

static Datum Int16GetDatum(int16 X)

static Datum MultiXactIdGetDatum(MultiXactId X)

static Datum BoolGetDatum(bool X)

static Datum ObjectIdGetDatum(Oid X)

static Datum NameGetDatum(const NameData *X)

static Datum CStringGetDatum(const char *X)

static Datum Int32GetDatum(int32 X)

static Datum CharGetDatum(char X)

void CheckTableForSerializableConflictIn(Relation relation)

void * stringToNode(const char *str)

#define RelationGetRelid(relation)

#define RelationGetDescr(relation)

#define RelationGetNumberOfAttributes(relation)

#define RelationGetRelationName(relation)

#define RelationGetNamespace(relation)

List * RelationGetIndexList(Relation relation)

void RelationForgetRelation(Oid rid)

Relation RelationBuildLocalRelation(const char *relname, Oid relnamespace, TupleDesc tupDesc, Oid relid, Oid accessmtd, RelFileNumber relfilenumber, Oid reltablespace, bool shared_relation, bool mapped_relation, char relpersistence, char relkind)

#define InvalidRelFileNumber

#define RelFileNumberIsValid(relnumber)

void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)

void relation_close(Relation relation, LOCKMODE lockmode)

Relation relation_open(Oid relationId, LOCKMODE lockmode)

void check_stack_depth(void)

SMgrRelation RelationCreateStorage(RelFileLocator rlocator, char relpersistence, bool register_delete)

void RelationDropStorage(Relation rel)

void RelationTruncate(Relation rel, BlockNumber nblocks)

#define BTEqualStrategyNumber

#define BTLessEqualStrategyNumber

#define ERRCODE_DUPLICATE_OBJECT

const char * p_sourcetext

RelFileLocator rd_locator

#define MinTransactionIdAttributeNumber

#define MaxCommandIdAttributeNumber

#define MaxTransactionIdAttributeNumber

#define TableOidAttributeNumber

#define SelfItemPointerAttributeNumber

#define MinCommandIdAttributeNumber

void ReleaseSysCache(HeapTuple tuple)

HeapTuple SearchSysCache1(int cacheId, Datum key1)

Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)

HeapTuple SearchSysCache2(int cacheId, Datum key1, Datum key2)

HeapTuple SearchSysCacheAttName(Oid relid, const char *attname)

#define SearchSysCacheCopy1(cacheId, key1)

#define SearchSysCacheCopy2(cacheId, key1, key2)

#define GetSysCacheOid2(cacheId, oidcol, key1, key2)

void table_close(Relation relation, LOCKMODE lockmode)

Relation table_open(Oid relationId, LOCKMODE lockmode)

static void table_relation_set_new_filelocator(Relation rel, const RelFileLocator *newrlocator, char persistence, TransactionId *freezeXid, MultiXactId *minmulti)

static void table_relation_nontransactional_truncate(Relation rel)

void CheckTableNotInUse(Relation rel, const char *stmt)

void remove_on_commit_action(Oid relid)

void register_on_commit_action(Oid relid, OnCommitAction action)

#define InvalidTransactionId

void FreeTupleDesc(TupleDesc tupdesc)

TupleDesc CreateTupleDesc(int natts, Form_pg_attribute *attrs)

static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)

static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)

Oid AssignTypeArrayOid(void)

bool contain_var_clause(Node *node)

List * pull_var_clause(Node *node, int flags)

void CommandCounterIncrement(void)